void Main ()
{
int ppid, pid1, pid2;
ppid = Getpid ();
if ((pid1 = Fork ()) == 0) {
/* first child executes here */
if ((pid2 = Fork ()) == 0) {
/* Second child executes here */
Printf ("I am the second child, my pid is %d\n", Getpid());
Yield(ppid);
Exit();
}
Printf ("I am the first child, my pid is %d\n", Getpid ());
Yield(pid2);
Exit ();
}
Yield (pid1);
Printf ("I am the parent, my pid is %d\n", Getpid ());
}
void Main ()
{
int pid;
if ((pid = Fork ()) == 0) {
/* child executes here */
Printf ("I am the child, my pid is %d\n", Getpid ());
Exit();
}
Printf ("I am the parent, my pid is %d\n", Getpid ());
Printf ("I just created a child process whose pid is %d\n", pid);
}
/* returns 0 if it could create lock; 1 if the lock exists; -1 on error */
int xiogetlock(const char *lockfile) {
char *s;
struct stat strat;
int fd;
pid_t pid;
char pidbuf[3*sizeof(pid_t)+1];
size_t bytes;
if (Lstat(lockfile, &strat) == 0) {
return 1;
}
switch (errno) {
case ENOENT: break;
default:
Error3("Lstat(\"%s\", %p): %s", lockfile, &strat, strerror(errno));
return -1;
}
/* in this moment, the file did not exist */
if ((s = Malloc(strlen(lockfile)+8)) == NULL) {
errno = ENOMEM;
return -1;
}
strcpy(s, lockfile);
strcat(s, ".XXXXXX");
if ((fd = Mkstemp(s)) < 0) {
Error2("mkstemp(\"%s\"): %s", s, strerror(errno));
return -1;
}
pid = Getpid();
bytes = sprintf(pidbuf, F_pid, pid);
if (writefull(fd, pidbuf, bytes) < 0) {
Error4("write(%d, %p, "F_Zu"): %s", fd, pidbuf, bytes, strerror(errno));
return -1;
}
Close(fd);
/* Chmod(lockfile, 0600); */
if (Link(s, lockfile) < 0) {
int _errno = errno;
Error3("link(\"%s\", \"%s\"): %s", s, lockfile, strerror(errno));
Unlink(s);
errno = _errno;
return -1;
}
Unlink(s);
return 0;
}
void Main ()
{
int i, p, c, r;
for (i = 0, p = Getpid (); i < NUMPROCS; i++, p = c) {
Printf ("%d about to fork\n", Getpid ());
if ((c = Fork ()) == 0) {
Printf ("%d starting\n", Getpid ());
handoff (p);
Printf ("%d exiting\n", Getpid ());
Exit ();
}
Printf ("%d just forked %d\n", Getpid (), c);
}
Printf ("%d yielding to %d\n", Getpid (), c);
r = Yield (c);
Printf ("%d resumed by %d, yielding to %d\n", Getpid (), r, c);
Yield (c);
Printf ("%d exiting\n", Getpid ());
}
static int xioopen_unix_listen(int argc, const char *argv[], struct opt *opts, int xioflags, xiofile_t *xxfd, unsigned groups, int abstract, int dummy2, int dummy3) {
/* we expect the form: filename */
const char *name;
xiosingle_t *xfd = &xxfd->stream;
int pf = PF_UNIX;
int socktype = SOCK_STREAM;
int protocol = 0;
struct sockaddr_un us;
socklen_t uslen;
bool tight = true;
struct opt *opts0 = NULL;
pid_t pid = Getpid();
bool opt_unlink_early = false;
bool opt_unlink_close = true;
int result;
if (argc != 2) {
Error2("%s: wrong number of parameters (%d instead of 1)",
argv[0], argc-1);
return STAT_NORETRY;
}
name = argv[1];
retropt_socket_pf(opts, &pf);
retropt_bool(opts, OPT_UNIX_TIGHTSOCKLEN, &tight);
uslen = xiosetunix(pf, &us, name, abstract, tight);
xfd->howtoend = END_SHUTDOWN;
if (!(ABSTRACT && abstract)) {
/* only for non abstract because abstract do not work in file system */
retropt_bool(opts, OPT_UNLINK_EARLY, &opt_unlink_early);
retropt_bool(opts, OPT_UNLINK_CLOSE, &opt_unlink_close);
}
if (applyopts_single(xfd, opts, PH_INIT) < 0) return STAT_NORETRY;
applyopts(-1, opts, PH_INIT);
applyopts(-1, opts, PH_EARLY);
if (!(ABSTRACT && abstract)) {
if (opt_unlink_early) {
if (Unlink(name) < 0) {
if (errno == ENOENT) {
Warn2("unlink(\"%s\"): %s", name, strerror(errno));
} else {
Error2("unlink(\"%s\"): %s", name, strerror(errno));
}
}
}
/* trying to set user-early, perm-early etc. here is useless because
file system entry is available only past bind() call. */
applyopts_named(name, opts, PH_EARLY); /* umask! */
}
opts0 = copyopts(opts, GROUP_ALL);
if ((result =
xioopen_listen(xfd, xioflags,
(struct sockaddr *)&us, uslen,
opts, opts0, pf, socktype, protocol))
!= 0)
return result;
/* we set this option as late as now because we should not remove an
existing entry when bind() failed */
if (!(ABSTRACT && abstract)) {
if (opt_unlink_close) {
if (pid == Getpid()) {
if ((xfd->unlink_close = strdup(name)) == NULL) {
Error1("strdup(\"%s\"): out of memory", name);
}
xfd->opt_unlink_close = true;
}
}
}
return 0;
}
TVerdict CTestSyscalls::doTestStepL()
{
int err;
if(TestStepName() == KCreat)
{
INFO_PRINTF1(_L("Creat():"));
err = Creat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen1)
{
INFO_PRINTF1(_L("open1():"));
err = open1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen2)
{
INFO_PRINTF1(_L("open2():"));
err = open2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen3)
{
INFO_PRINTF1(_L("open3():"));
err = open3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen4)
{
INFO_PRINTF1(_L("open4():"));
err = open4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen5)
{
INFO_PRINTF1(_L("open5():"));
err = open5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen6)
{
INFO_PRINTF1(_L("open6():"));
err = open6();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenTruncate1)
{
INFO_PRINTF1(_L("OpenTruncate1:"));
err = OpenTruncate1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenTruncate2)
{
INFO_PRINTF1(_L("OpenTruncate2:"));
err = OpenTruncate2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen7)
{
INFO_PRINTF1(_L("open7():"));
err = open7();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenInAppendMode)
{
INFO_PRINTF1(_L("OpenInAppendMode():"));
err = OpenInAppendMode();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite1)
{
INFO_PRINTF1(_L("write1():"));
err = write1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite2)
{
INFO_PRINTF1(_L("write2():"));
err = write2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite3)
{
INFO_PRINTF1(_L("write3():"));
err = write3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite5)
{
INFO_PRINTF1(_L("write5():"));
err = write5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread1)
{
INFO_PRINTF1(_L("read1():"));
err = read1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread2)
{
INFO_PRINTF1(_L("read2():"));
err = read2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread3)
{
INFO_PRINTF1(_L("read3():"));
err = read3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread4)
{
INFO_PRINTF1(_L("read4():"));
err = read4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpendir)
{
INFO_PRINTF1(_L("Opendir():"));
err = Opendir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClosedir)
{
INFO_PRINTF1(_L("Closedir():"));
err = Closedir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReaddir)
{
INFO_PRINTF1(_L("Readdir():"));
err = Readdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseek)
{
INFO_PRINTF1(_L("Lseek():"));
err = Lseek();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseek1)
{
INFO_PRINTF1(_L("Lseek1():"));
err = Lseek1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KAccess)
{
INFO_PRINTF1(_L("Access():"));
err = Access();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KAccess1)
{
INFO_PRINTF1(_L("Access1():"));
err = Access1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KDup)
{
INFO_PRINTF1(_L("Dup():"));
err = Dup();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KDup2)
{
INFO_PRINTF1(_L("Dup2():"));
err = Dup2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename)
{
INFO_PRINTF1(_L("Rename():"));
err = Rename();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename1)
{
INFO_PRINTF1(_L("Rename1():"));
err = Rename1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod)
{
INFO_PRINTF1(_L("Chmod():"));
err = Chmod();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod1)
{
INFO_PRINTF1(_L("Chmod1():"));
err = Chmod1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod_dir)
{
INFO_PRINTF1(_L("Chmod_dir():"));
err = Chmod_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFChmod)
{
INFO_PRINTF1(_L("FChmod():"));
err = FChmod();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFChmod_dir)
{
INFO_PRINTF1(_L("FChmod_dir():"));
err = FChmod_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KExit)
{
INFO_PRINTF1(_L("Exit():"));
err = Exit();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClose)
{
INFO_PRINTF1(_L("Close():"));
err = Close();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir)
{
INFO_PRINTF1(_L("Mkdir():"));
err = Mkdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMk_dir)
{
INFO_PRINTF1(_L("Mk_dir():"));
err = Mk_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir)
{
INFO_PRINTF1(_L("Rmdir():"));
err = Rmdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRm_dir)
{
INFO_PRINTF1(_L("Rm_dir():"));
err = Rm_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir1)
{
INFO_PRINTF1(_L("Rmdir1():"));
err = Rmdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir_Chdir)
{
INFO_PRINTF1(_L("Rmdir_Chdir():"));
err = Rmdir_Chdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFsync)
{
INFO_PRINTF1(_L("Fsync():"));
err = Fsync();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes)
{
INFO_PRINTF1(_L("Utimes():"));
err = Utimes();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtime)
{
INFO_PRINTF1(_L("Utime():"));
err = Utime();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir)
{
INFO_PRINTF1(_L("Chdir():"));
err = Chdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFcntl)
{
INFO_PRINTF1(_L("Fcntl():"));
err = Fcntl();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KIoctl)
{
INFO_PRINTF1(_L("Ioctl():"));
err = Ioctl();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFstat)
{
INFO_PRINTF1(_L("Fstat():"));
err = Fstat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat)
{
INFO_PRINTF1(_L("Stat():"));
err = Stat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat1)
{
INFO_PRINTF1(_L("Stat1():"));
err = Stat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat2)
{
INFO_PRINTF1(_L("Stat2():"));
err = Stat2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat3)
{
INFO_PRINTF1(_L("Stat3():"));
err = Stat3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KGetpid)
{
INFO_PRINTF1(_L("Getpid():"));
err = Getpid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClock)
{
INFO_PRINTF1(_L("Clock():"));
err = Clock();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTime)
{
INFO_PRINTF1(_L("Time():"));
err = Time();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaitPid)
{
INFO_PRINTF1(_L("WaitPid():"));
err = WaitPid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReadV)
{
INFO_PRINTF1(_L("ReadV():"));
err = ReadV();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWriteV)
{
INFO_PRINTF1(_L("WriteV():"));
err = WriteV();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KSleep)
{
INFO_PRINTF1(_L("Sleep():"));
err = Sleep();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KSeekDir)
{
INFO_PRINTF1(_L("SeekDir():"));
err = SeekDir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRewindDir)
{
INFO_PRINTF1(_L("RewindDir():"));
err = RewindDir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTelldir)
{
INFO_PRINTF1(_L("Telldir():"));
err = Telldir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTestClock)
{
INFO_PRINTF1(_L("TestClock():"));
err = TestClock();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KCreat2)
{
INFO_PRINTF1(_L("Creat2():"));
err = Creat2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen8)
{
INFO_PRINTF1(_L("open8():"));
err = open8();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTestStat)
{
INFO_PRINTF1(_L("KTestStat():"));
err = TestStat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseekttytest1)
{
INFO_PRINTF1(_L("Lseekttytest1():"));
err = Lseekttytest1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseekttytest2)
{
INFO_PRINTF1(_L("Lseekttytest2():"));
err = Lseekttytest2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaitPidtest)
{
INFO_PRINTF1(_L("WaitPidtest():"));
err = WaitPidtest();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaittest)
{
INFO_PRINTF1(_L("Waittest():"));
err = Waittest();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpen_FileDes_Test)
{
INFO_PRINTF1(_L("Open_FileDes_Test():"));
err = Open_FileDes_Test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopenuid)
{
INFO_PRINTF1(_L("openuid():"));
err = openuid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir1)
{
INFO_PRINTF1(_L("Mkdir1():"));
err = Mkdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir2)
{
INFO_PRINTF1(_L("Mkdir2():"));
err = Mkdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename2)
{
INFO_PRINTF1(_L("Rename2():"));
err = Rename2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestfsync)
{
INFO_PRINTF1(_L("testfsync():"));
err = testfsync();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestrename)
{
INFO_PRINTF1(_L("testrename():"));
err = testrename();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestopenvalidate)
{
INFO_PRINTF1(_L("testopenvalidate():"));
err = testopenvalidate();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ksync_safe)
{
INFO_PRINTF1(_L("sync_safe():"));
err = sync_safe();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFstat1)
{
INFO_PRINTF1(_L("Fstat1():"));
err = Fstat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes1)
{
INFO_PRINTF1(_L("Utimes1():"));
err = Utimes1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir_test1)
{
INFO_PRINTF1(_L("Mkdir_test1():"));
err = Mkdir_test1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod_test)
{
INFO_PRINTF1(_L("Chmod_test():"));
err = Chmod_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir1)
{
INFO_PRINTF1(_L("Chdir1():"));
err = Chdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir2)
{
INFO_PRINTF1(_L("Rmdir2():"));
err = Rmdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename_test)
{
INFO_PRINTF1(_L("Rename_test():"));
err = Rename_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename3)
{
INFO_PRINTF1(_L("Rename3():"));
err = Rename3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KCreat1)
{
INFO_PRINTF1(_L("Creat1():"));
err = Creat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReadV1)
{
INFO_PRINTF1(_L("ReadV1():"));
err = ReadV1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes2)
{
INFO_PRINTF1(_L("Utimes2():"));
err = Utimes2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat_test)
{
INFO_PRINTF1(_L("Stat_test():"));
err = Stat_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir_test2)
{
INFO_PRINTF1(_L("Mkdir_test2():"));
err = Mkdir_test2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod2)
{
INFO_PRINTF1(_L("Chmod2():"));
err = Chmod2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir2)
{
INFO_PRINTF1(_L("Chdir2():"));
err = Chdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename4)
{
INFO_PRINTF1(_L("Rename4():"));
err = Rename4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename5)
{
INFO_PRINTF1(_L("Rename5():"));
err = Rename5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir3)
{
INFO_PRINTF1(_L("Rmdir3():"));
err = Rmdir3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread5)
{
INFO_PRINTF1(_L("read5():"));
err = read5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
return TestStepResult();
}
/* creates the listening socket, bind, applies options; waits for incoming
connection, checks its source address and port. Depending on fork option, it
may fork a subprocess.
pf specifies the syntax expected for range option. In the case of generic
socket it is 0 (expecting raw binary data), and the real pf can be obtained
from us->af_family; for other socket types pf == us->af_family
Returns 0 if a connection was accepted; with fork option, this is always in
a subprocess!
Other return values indicate a problem; this can happen in the master
process or in a subprocess.
This function does not retry. If you need retries, handle this in a
loop in the calling function (and always provide the options...)
After fork, we set the forever/retry of the child process to 0
applies and consumes the following option:
PH_INIT, PH_PASTSOCKET, PH_PREBIND, PH_BIND, PH_PASTBIND, PH_EARLY,
PH_PREOPEN, PH_FD, PH_CONNECTED, PH_LATE, PH_LATE2
OPT_FORK, OPT_SO_TYPE, OPT_SO_PROTOTYPE, OPT_BACKLOG, OPT_RANGE, tcpwrap,
OPT_SOURCEPORT, OPT_LOWPORT, cloexec
*/
int _xioopen_listen(struct single *xfd, int xioflags, struct sockaddr *us, socklen_t uslen,
struct opt *opts, int pf, int socktype, int proto, int level) {
struct sockaddr sa;
socklen_t salen;
int backlog = 5; /* why? 1 seems to cause problems under some load */
char *rangename;
bool dofork = false;
int maxchildren = 0;
char infobuff[256];
char lisname[256];
union sockaddr_union _peername;
union sockaddr_union _sockname;
union sockaddr_union *pa = &_peername; /* peer address */
union sockaddr_union *la = &_sockname; /* local address */
socklen_t pas = sizeof(_peername); /* peer address size */
socklen_t las = sizeof(_sockname); /* local address size */
int result;
retropt_bool(opts, OPT_FORK, &dofork);
if (dofork) {
if (!(xioflags & XIO_MAYFORK)) {
Error("option fork not allowed here");
return STAT_NORETRY;
}
xfd->flags |= XIO_DOESFORK;
}
retropt_int(opts, OPT_MAX_CHILDREN, &maxchildren);
if (! dofork && maxchildren) {
Error("option max-children not allowed without option fork");
return STAT_NORETRY;
}
if (applyopts_single(xfd, opts, PH_INIT) < 0) return -1;
if (dofork) {
xiosetchilddied(); /* set SIGCHLD handler */
}
if ((xfd->fd = xiosocket(opts, us->sa_family, socktype, proto, level)) < 0) {
return STAT_RETRYLATER;
}
applyopts_cloexec(xfd->fd, opts);
applyopts(xfd->fd, opts, PH_PREBIND);
applyopts(xfd->fd, opts, PH_BIND);
if (Bind(xfd->fd, (struct sockaddr *)us, uslen) < 0) {
Msg4(level, "bind(%d, {%s}, "F_socklen"): %s", xfd->fd,
sockaddr_info(us, uslen, infobuff, sizeof(infobuff)), uslen,
strerror(errno));
Close(xfd->fd);
return STAT_RETRYLATER;
}
#if WITH_UNIX
if (us->sa_family == AF_UNIX) {
applyopts_named(((struct sockaddr_un *)us)->sun_path, opts, PH_FD);
}
#endif
/* under some circumstances (e.g., TCP listen on port 0) bind() fills empty
fields that we want to know. */
salen = sizeof(sa);
if (Getsockname(xfd->fd, us, &uslen) < 0) {
Warn4("getsockname(%d, %p, {%d}): %s",
xfd->fd, &us, uslen, strerror(errno));
}
applyopts(xfd->fd, opts, PH_PASTBIND);
#if WITH_UNIX
if (us->sa_family == AF_UNIX) {
/*applyopts_early(((struct sockaddr_un *)us)->sun_path, opts);*/
applyopts_named(((struct sockaddr_un *)us)->sun_path, opts, PH_EARLY);
applyopts_named(((struct sockaddr_un *)us)->sun_path, opts, PH_PREOPEN);
}
#endif /* WITH_UNIX */
#if WITH_IP4 /*|| WITH_IP6*/
if (retropt_string(opts, OPT_RANGE, &rangename) >= 0) {
if (xioparserange(rangename, pf, &xfd->para.socket.range)
< 0) {
free(rangename);
return STAT_NORETRY;
}
free(rangename);
xfd->para.socket.dorange = true;
}
#endif
#if (WITH_TCP || WITH_UDP) && WITH_LIBWRAP
xio_retropt_tcpwrap(xfd, opts);
#endif /* && (WITH_TCP || WITH_UDP) && WITH_LIBWRAP */
#if WITH_TCP || WITH_UDP
if (retropt_ushort(opts, OPT_SOURCEPORT, &xfd->para.socket.ip.sourceport) >= 0) {
xfd->para.socket.ip.dosourceport = true;
}
retropt_bool(opts, OPT_LOWPORT, &xfd->para.socket.ip.lowport);
#endif /* WITH_TCP || WITH_UDP */
applyopts(xfd->fd, opts, PH_PRELISTEN);
retropt_int(opts, OPT_BACKLOG, &backlog);
if (Listen(xfd->fd, backlog) < 0) {
Error3("listen(%d, %d): %s", xfd->fd, backlog, strerror(errno));
return STAT_RETRYLATER;
}
if (xioopts.logopt == 'm') {
Info("starting accept loop, switching to syslog");
diag_set('y', xioopts.syslogfac); xioopts.logopt = 'y';
} else {
Info("starting accept loop");
}
while (true) { /* but we only loop if fork option is set */
char peername[256];
char sockname[256];
int ps; /* peer socket */
pa = &_peername;
la = &_sockname;
salen = sizeof(struct sockaddr);
do {
/*? int level = E_ERROR;*/
Notice1("listening on %s", sockaddr_info(us, uslen, lisname, sizeof(lisname)));
ps = Accept(xfd->fd, (struct sockaddr *)&sa, &salen);
if (ps >= 0) {
/*0 Info4("accept(%d, %p, {"F_Zu"}) -> %d", xfd->fd, &sa, salen, ps);*/
break; /* success, break out of loop */
}
if (errno == EINTR) {
continue;
}
if (errno == ECONNABORTED) {
Notice4("accept(%d, %p, {"F_socklen"}): %s",
xfd->fd, &sa, salen, strerror(errno));
continue;
}
Msg4(level, "accept(%d, %p, {"F_socklen"}): %s",
xfd->fd, &sa, salen, strerror(errno));
Close(xfd->fd);
return STAT_RETRYLATER;
} while (true);
applyopts_cloexec(ps, opts);
if (Getpeername(ps, &pa->soa, &pas) < 0) {
Warn4("getpeername(%d, %p, {"F_socklen"}): %s",
ps, pa, pas, strerror(errno));
pa = NULL;
}
if (Getsockname(ps, &la->soa, &las) < 0) {
Warn4("getsockname(%d, %p, {"F_socklen"}): %s",
ps, la, las, strerror(errno));
la = NULL;
}
Notice2("accepting connection from %s on %s",
pa?
sockaddr_info(&pa->soa, pas, peername, sizeof(peername)):"NULL",
la?
sockaddr_info(&la->soa, las, sockname, sizeof(sockname)):"NULL");
if (pa != NULL && la != NULL && xiocheckpeer(xfd, pa, la) < 0) {
if (Shutdown(ps, 2) < 0) {
Info2("shutdown(%d, 2): %s", ps, strerror(errno));
}
Close(ps);
continue;
}
if (pa != NULL)
Info1("permitting connection from %s",
sockaddr_info((struct sockaddr *)pa, pas,
infobuff, sizeof(infobuff)));
if (dofork) {
pid_t pid; /* mostly int; only used with fork */
sigset_t mask_sigchld;
/* we must prevent that the current packet triggers another fork;
therefore we wait for a signal from the recent child: USR1
indicates that is has consumed the last packet; CHLD means it has
terminated */
/* block SIGCHLD and SIGUSR1 until parent is ready to react */
sigemptyset(&mask_sigchld);
sigaddset(&mask_sigchld, SIGCHLD);
Sigprocmask(SIG_BLOCK, &mask_sigchld, NULL);
if ((pid = xio_fork(false, level==E_ERROR?level:E_WARN)) < 0) {
Close(xfd->fd);
Sigprocmask(SIG_UNBLOCK, &mask_sigchld, NULL);
return STAT_RETRYLATER;
}
if (pid == 0) { /* child */
pid_t cpid = Getpid();
Sigprocmask(SIG_UNBLOCK, &mask_sigchld, NULL);
Info1("just born: child process "F_pid, cpid);
xiosetenvulong("PID", cpid, 1);
if (Close(xfd->fd) < 0) {
Info2("close(%d): %s", xfd->fd, strerror(errno));
}
xfd->fd = ps;
#if WITH_RETRY
/* !? */
xfd->forever = false; xfd->retry = 0;
level = E_ERROR;
#endif /* WITH_RETRY */
break;
}
/* server: continue loop with listen */
/* shutdown() closes the socket even for the child process, but
close() does what we want */
if (Close(ps) < 0) {
Info2("close(%d): %s", ps, strerror(errno));
}
/* now we are ready to handle signals */
Sigprocmask(SIG_UNBLOCK, &mask_sigchld, NULL);
while (maxchildren) {
if (num_child < maxchildren) break;
Notice("maxchildren are active, waiting");
/* UINT_MAX would even be nicer, but Openindiana works only
with 31 bits */
while (!Sleep(INT_MAX)) ; /* any signal lets us continue */
}
Info("still listening");
} else {
if (Close(xfd->fd) < 0) {
Info2("close(%d): %s", xfd->fd, strerror(errno));
}
xfd->fd = ps;
break;
}
}
applyopts(xfd->fd, opts, PH_FD);
applyopts(xfd->fd, opts, PH_PASTSOCKET);
applyopts(xfd->fd, opts, PH_CONNECTED);
if ((result = _xio_openlate(xfd, opts)) < 0)
return result;
/* set the env vars describing the local and remote sockets */
if (la != NULL) xiosetsockaddrenv("SOCK", la, las, proto);
if (pa != NULL) xiosetsockaddrenv("PEER", pa, pas, proto);
return 0;
}
int procan(FILE *outfile) {
/*filan(0, outfile);*/
/* controlling terminal */
fprintf(outfile, "process id = "F_pid"\n", Getpid());
fprintf(outfile, "process parent id = "F_pid"\n", Getppid());
{
int fd;
if ((fd = Open("/dev/tty", O_NOCTTY, 0)) < 0) {
fprintf(outfile, "controlling terminal: -\n");
} else {
#if 1
fprintf(outfile, "controlling terminal: \"%s\"\n", Ttyname(fd));
#else
char procpath[PATH_MAX], devpath[PATH_MAX+1];
int devlen;
sprintf(procpath, "/proc/"F_pid"/fd/%d", Getpid(), 0 /*! fd*/);
if ((devlen = Readlink(procpath, devpath, sizeof(devpath))) < 0) {
;
} else {
devpath[devlen] = '\0';
fprintf(outfile, "controlling terminal: \"%s\"\n", devpath);
}
#endif
}
}
fprintf(outfile, "process group id = "F_pid"\n", Getpgrp());
#if HAVE_GETSID
fprintf(outfile, "process session id = "F_pid"\n", Getsid(0));
#endif
fprintf(outfile, "process group id if fg process / stdin = "F_pid"\n", Tcgetpgrp(0));
fprintf(outfile, "process group id if fg process / stdout = "F_pid"\n", Tcgetpgrp(1));
fprintf(outfile, "process group id if fg process / stderr = "F_pid"\n", Tcgetpgrp(2));
{
int fd;
if ((fd = Open("/dev/tty", O_RDWR, 0600)) >= 0) {
fprintf(outfile, "process has a controlling terminal\n");
Close(fd);
} else {
fprintf(outfile, "process does not have a controlling terminal\n");
}
}
/* process owner, groups */
fprintf(outfile, "user id = "F_uid"\n", Getuid());
fprintf(outfile, "effective user id = "F_uid"\n", Geteuid());
fprintf(outfile, "group id = "F_gid"\n", Getgid());
fprintf(outfile, "effective group id = "F_gid"\n", Getegid());
{
struct rlimit rlim;
fprintf(outfile, "\nRESOURCE LIMITS\n");
fprintf(outfile, "resource current maximum\n");
if (getrlimit(RLIMIT_CPU, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_CPU, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"cpu time (seconds) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_FSIZE, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_FSIZE, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"file size (blocks) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_DATA, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_DATA, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"data seg size (kbytes) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_STACK, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_STACK, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"stack size (blocks) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
if (getrlimit(RLIMIT_CORE, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_CORE, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"core file size (blocks) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#ifdef RLIMIT_RSS /* Linux, AIX; not Cygwin */
if (getrlimit(RLIMIT_RSS, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_RSS, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"max resident set size %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#endif
#ifdef RLIMIT_NPROC /* Linux, not AIX, Cygwin */
if (getrlimit(RLIMIT_NPROC, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_NPROC, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"max user processes %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#endif
#ifdef RLIMIT_NOFILE /* not AIX 4.1 */
if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_NOFILE, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"open files %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#endif
#ifdef RLIMIT_MEMLOCK /* Linux, not AIX, Cygwin */
if (getrlimit(RLIMIT_MEMLOCK, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_MEMLOCK, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"max locked-in-memory address space %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#endif
#ifdef RLIMIT_AS
if (getrlimit(RLIMIT_AS, &rlim) < 0) {
Warn2("getrlimit(RLIMIT_AS, %p): %s", &rlim, strerror(errno));
} else {
fprintf(outfile,
"virtual memory (kbytes) %16"F_rlim_max"%16"F_rlim_max"\n",
rlim.rlim_cur, rlim.rlim_max);
}
#endif
}
/* file descriptors */
/* what was this for?? */
/*Sleep(1);*/
return 0;
}
