int main(int argc, char **argv)
{
struct stat stat;
char *type, *readok;
//printf("%d\n", *argv[1]-'0');
//return 0;
/* 很重要 */
if (argc != 2) {
fprintf(stderr, "usage: %s <fd>\n", argv[0]);
exit(0);
}
Fstat(*argv[1]-'0', &stat);
if (S_ISREG(stat.st_mode))
type = "regular";
else if (S_ISDIR(stat.st_mode))
type = "directory";
else
type = "other";
/* 检查读权限 */
if ((stat.st_mode & S_IWUSR))
readok = "yes";
else
readok = "no";
printf("type: %s, read: %s\n", type, readok);
exit(0);
}
int
main(int argc, char **argv)
{
int fd;
struct stat stat;
struct door_info info;
if (argc != 2)
err_quit("usage: doorinfo <pathname>");
fd = Open(argv[1], O_RDONLY);
Fstat(fd, &stat);
if (S_ISDOOR(stat.st_mode) == 0)
err_quit("pathname is not a door");
Door_info(fd, &info);
printf("server PID = %ld, uniquifier = %ld",
(long) info.di_target, (long) info.di_uniquifier);
if (info.di_attributes & DOOR_LOCAL)
printf(", DOOR_LOCAL");
if (info.di_attributes & DOOR_PRIVATE)
printf(", DOOR_PRIVATE");
if (info.di_attributes & DOOR_REVOKED)
printf(", DOOR_REVOKED");
if (info.di_attributes & DOOR_UNREF)
printf(", DOOR_UNREF");
printf("\n");
exit(0);
}
int
main(int argc, char **argv)
{
struct stat stat;
if (argc != 2)
err_quit("usage: server1 <pathname>");
Door_server_create(my_create);
/* 4create a door descriptor */
fd = Door_create(server, (void *) 44, DOOR_PRIVATE);
Fstat(fd, &stat);
printf("server() at %p, fmt = %lx\n", server,
(long) stat.st_mode & S_IFMT);
/* 4bind it to the specified pathname */
unlink(argv[1]);
Close(Open(argv[1], O_CREAT | O_EXCL | O_RDWR, FILE_MODE));
Fattach(fd, argv[1]);
/* Close(fd); */
/* server() handles all client requests */
for ( ; ; )
pause();
}
int main(int argc, char **argv)
{
int fd1, fd2, *ptr1, *ptr2;
pid_t childpid;
struct stat stat;
if (argc != 2)
err_quit("Usage: test2 <name>");
Shm_unlink(Px_ipc_name(argv[1]));
fd1 = Shm_open(Px_ipc_name(argv[1]), O_RDWR | O_CREAT | O_EXCL, FILE_MODE);
Ftruncate(fd1, sizeof(int));
fd2 = Open("./shm", O_RDONLY);
Fstat(fd2, &stat);
if ((childpid = Fork()) == 0) {
ptr2 = Mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd2, 0);
ptr1 = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);
printf("child: shm ptr = %p, motd ptr = %p\n", ptr1, ptr2);
sleep(5);
printf("shared memory integer = %d\n", *ptr1);
exit(0);
}
//parent: map in reverse order from child
ptr1 = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);
ptr2 = Mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd2, 0);
*ptr1 = 777;
Waitpid(childpid, NULL, 0);
exit(0);
}
IV
PerlIOMmap_map(pTHX_ PerlIO *f)
{
dVAR;
PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
const IV flags = PerlIOBase(f)->flags;
IV code = 0;
if (m->len)
abort();
if (flags & PERLIO_F_CANREAD) {
PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
const int fd = PerlIO_fileno(f);
Stat_t st;
code = Fstat(fd, &st);
if (code == 0 && S_ISREG(st.st_mode)) {
SSize_t len = st.st_size - b->posn;
if (len > 0) {
Off_t posn;
if (PL_mmap_page_size <= 0)
Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
PL_mmap_page_size);
if (b->posn < 0) {
/*
* This is a hack - should never happen - open should
* have set it !
*/
b->posn = PerlIO_tell(PerlIONext(f));
}
posn = (b->posn / PL_mmap_page_size) * PL_mmap_page_size;
len = st.st_size - posn;
m->mptr = (Mmap_t)mmap(NULL, len, PROT_READ, MAP_SHARED, fd, posn);
if (m->mptr && m->mptr != (Mmap_t) - 1) {
#if 0 && defined(HAS_MADVISE) && defined(MADV_SEQUENTIAL)
madvise(m->mptr, len, MADV_SEQUENTIAL);
#endif
#if 0 && defined(HAS_MADVISE) && defined(MADV_WILLNEED)
madvise(m->mptr, len, MADV_WILLNEED);
#endif
PerlIOBase(f)->flags =
(flags & ~PERLIO_F_EOF) | PERLIO_F_RDBUF;
b->end = ((STDCHAR *) m->mptr) + len;
b->buf = ((STDCHAR *) m->mptr) + (b->posn - posn);
b->ptr = b->buf;
m->len = len;
}
else {
b->buf = NULL;
}
}
else {
PerlIOBase(f)->flags =
flags | PERLIO_F_EOF | PERLIO_F_RDBUF;
b->buf = NULL;
b->ptr = b->end = b->ptr;
code = -1;
}
}
}
return code;
}
/* mmapcopy driver */
int main(int argc, char **argv)
{
struct stat stat;
int fd;
/* Check for required cmd line arg */
if (argc != 2) {
printf("usage: %s <filename>\n",
argv[0]);
exit(0);
}
/* Copy input file to stdout */
fd = Open(argv[1], O_RDONLY, 0);
Fstat(fd, &stat);
mmapcopy(fd, stat.st_size);
exit(0);
}
int main(int argc,char **argv)
{
int i,fd;
unsigned char c,*ptr;
struct stat stat;
if(argc!=2)
err_quit("usgae: shmread <name>");
fd=Shm_open(argv[1],O_RDONLY,FILE_MODE);
Fstat(fd,&stat);
ptr=Mmap(NULL,stat.st_size,PROT_READ,MAP_SHARED,fd,0);
Close(fd);
for(i=0;i<stat.st_size;i++)
if((c=*ptr++)!=(i%256))
err_ret("ptr[%d] =%d",i,c);
exit(0);
}
int
main(int argc, char **argv)
{
int fd;
long ivals[4], ovals[4];
door_arg_t arg;
struct stat stat;
struct door_info info;
if (argc != 2)
err_quit("usage: client1 <pathname>");
fd = Open(argv[1], O_RDWR);
Fstat(fd, &stat);
printf("pid = %ld, fmt = %lx\n",
(long) getpid(), (long) stat.st_mode & S_IFMT);
Door_info(fd, &info);
printf("di_target = %ld, di_proc = %p, di_data = %p, di_attr = %x\n",
(long) info.di_target, (void *) info.di_proc,
(void *) info.di_data, info.di_attributes);
ivals[0] = 1;
ivals[1] = 3;
ivals[2] = 6;
ivals[3] = 9;
arg.data_ptr = (char *) ivals;
arg.data_size = 4 * sizeof(long);
arg.desc_ptr = NULL;
arg.desc_num = 0;
arg.rbuf = (char *) ovals;
arg.rsize = sizeof(ovals);
Door_call(fd, &arg);
if (arg.data_ptr != (char *) ovals)
printf("arg.data_ptr = %p\n", arg.data_ptr);
printf("result: %ld %ld %ld %ld\n",
ovals[0], ovals[1], ovals[2], ovals[3]);
exit(0);
}
int main(int argc, char **argv)
{
int i, fd;
struct stat stat;
unsigned char c, *ptr;
if (argc != 2)
err_quit("Usage: read <name>");
//open, get size, map
fd = Shm_open(argv[1], O_RDONLY, FILE_MODE);
Fstat(fd, &stat);
ptr = Mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd, 0);
Close(fd);
//check teh ptr[0] = 0, ptr[1] = 1, etc.
for (i = 0; i < stat.st_size; i++)
if ((c = *ptr++) != (i % 256))
err_ret("ptr[%d] = %d", i, c);
exit(0);
}
static int
test_offset64(void){
struct stat sta;
int fd,ret = -1;
// FIXME off_t off;
if((fd = OpenCreat(TESTFILE,O_RDWR | O_CREAT,755)) < 0){
goto done;
}
if(Fstat(fd,&sta)){
goto done;
}
// FIXME what is to be done with this?
//off = 0x1ffffffffLL;
ret = 0;
done:
if(fd >= 0){
ret |= Close(fd);
}
Unlink(TESTFILE);
return ret;
}
int
main(int argc, char **argv)
{
int i, fd;
struct stat stat;
unsigned char *ptr;
if (argc != 2)
err_quit("usage: shmwrite <name>");
/* open, get size, map */
fd = Shm_open(argv[1], O_RDWR, FILE_MODE);
Fstat(fd, &stat);
ptr = Mmap(NULL, stat.st_size, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
Close(fd);
/* set: ptr[0] = 0, ptr[1] = 1, etc. */
for (i = 0; i < stat.st_size; i++)
*ptr++ = i % 256;
exit(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();
}
int main(int argc, char *argv[])
{
int connection_file_descriptor;
char temp_line[BUFFER];
char temp_char1, temp_char2;
struct sockaddr_in server_address;
struct sigaction act1;
int characters_read;
struct stat file_status;
int data_file_descriptor;
check_argument(argc,argv);
act1.sa_handler = close_properly;
sigemptyset(&act1.sa_mask);
act1.sa_flags=0;
sigaction(SIGINT, &act1, 0);
listen_file_descriptor = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&server_address, sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
server_address.sin_port = htons(atoi(argv[1]));
Bind(listen_file_descriptor, (struct sockaddr *) &server_address, sizeof(server_address));
Listen(listen_file_descriptor, 5);
while(1)
{
data_file_descriptor = Open(filename, O_RDONLY);
Fstat(data_file_descriptor, &file_status);
connection_file_descriptor = Accept(listen_file_descriptor, (struct sockaddr *) NULL, NULL);
characters_read = Read(connection_file_descriptor, &temp_char1, 1);
while(characters_read > 0)
{
//printf("%c",temp_char1);
characters_read = Read(connection_file_descriptor, &temp_char2, 1);
if(temp_char2=='\n' && temp_char1=='\r')
{
temp_char1=temp_char2;
//printf("%c",temp_char1);
characters_read = Read(connection_file_descriptor, &temp_char2, 1);
if(temp_char2=='\r')
{
printf("Received request\n");
printf("Sending HTTP response\n");
break;
}
}
temp_char1=temp_char2;
}
strcpy(temp_line, "HTTP/1.1 200 OK\n");
Write(connection_file_descriptor, temp_line, strlen(temp_line));
strcpy(temp_line, "Server: Barjatiya\n");
Write(connection_file_descriptor, temp_line, strlen(temp_line));
strcpy(temp_line, "Last-Modified: Fri, 29 Sep 2006 10:40:55 GMT\n");
Write(connection_file_descriptor, temp_line, strlen(temp_line));
strcpy(temp_line, "Accept-Ranges: bytes\n");
Write(connection_file_descriptor, temp_line, strlen(temp_line));
sprintf(temp_line, "Content-Length: %d\n", (int)file_status.st_size);
Write(connection_file_descriptor, temp_line, strlen(temp_line));
strcpy(temp_line, "Content-Type: text/html\n");
Write(connection_file_descriptor, temp_line, strlen(temp_line));
strcpy(temp_line, "\n");
Write(connection_file_descriptor, temp_line, strlen(temp_line));
printf("Sending file\n");
characters_read = Read(data_file_descriptor, temp_line, BUFFER -1);
while(characters_read > 0)
{
Write(connection_file_descriptor, temp_line, characters_read);
characters_read = Read(data_file_descriptor, temp_line, BUFFER -1);
}
Close(data_file_descriptor);
printf("File send complete\n");
Close(connection_file_descriptor);
printf("Connection closed\n\n");
}
return 0;
}
/* fork for exec/system, but return before exec'ing.
return=0: is child process
return>0: is parent process
return<0: error occurred, assume parent process and no child exists !!!
function formerly known as _xioopen_foxec()
*/
int _xioopen_progcall(int xioflags, /* XIO_RDONLY etc. */
struct single *xfd,
unsigned groups,
struct opt **copts, /* in: opts; out: opts for child */
int *duptostderr,
bool inter, /* is interaddr, not endpoint */
int form /* with interaddr: =2: FDs 1,0--4,3
=1: FDs 1--0 */
) {
struct single *fd = xfd;
struct opt *popts; /* parent process options */
int numleft;
int sv[2], rdpip[2], wrpip[2];
int saverfd = -1, savewfd = -1; /* with inter addr, save assigned right fds */
int rw = (xioflags & XIO_ACCMODE);
char *commname;
int commtype = XIOCOMM_SOCKETPAIRS;
bool usepipes = false;
#if HAVE_PTY
int ptyfd = -1, ttyfd = -1;
bool usebestpty = false; /* use the best available way to open pty */
#if defined(HAVE_DEV_PTMX) || defined(HAVE_DEV_PTC)
bool useptmx = false; /* use /dev/ptmx or equivalent */
#endif
#if HAVE_OPENPTY
bool useopenpty = false; /* try only openpty */
#endif /* HAVE_OPENPTY */
bool usepty = false; /* any of the pty options is selected */
char ptyname[MAXPTYNAMELEN];
#endif /* HAVE_PTY */
pid_t pid = 0; /* mostly int */
int leftfd[2] = { 0, 1 };
# define fdi (leftfd[0])
# define fdo (leftfd[1])
int rightfd[2] = { 3, 4 };
# define rightin (rightfd[0])
# define rightout (rightfd[1])
short result;
bool withstderr = false;
bool nofork = false;
bool withfork;
popts = moveopts(*copts, GROUP_ALL);
if (applyopts_single(fd, popts, PH_INIT) < 0) return -1;
applyopts2(-1, popts, PH_INIT, PH_EARLY);
retropt_bool(popts, OPT_NOFORK, &nofork);
withfork = !nofork;
if ((retropt_string(popts, OPT_COMMTYPE, &commname)) >= 0) {
if ((commtype = getcommtype(commname)) < 0) {
Error1("bad communication type \"%s\"", commname);
commtype = XIOCOMM_SOCKETPAIRS;
}
}
retropt_bool(popts, OPT_PIPES, &usepipes);
#if HAVE_PTY
retropt_bool(popts, OPT_PTY, &usebestpty);
#if HAVE_OPENPTY
retropt_bool(popts, OPT_OPENPTY, &useopenpty);
#endif
#if defined(HAVE_DEV_PTMX) || defined(HAVE_DEV_PTC)
retropt_bool(popts, OPT_PTMX, &useptmx);
#endif
usepty = (usebestpty
#if HAVE_OPENPTY
|| useopenpty
#endif
#if defined(HAVE_DEV_PTMX) || defined(HAVE_DEV_PTC)
|| useptmx
#endif
);
if (usepipes && usepty) {
Warn("_xioopen_foxec(): options \"pipes\" and \"pty\" must not be specified together; ignoring \"pipes\"");
usepipes = false;
}
#endif /* HAVE_PTY */
if (usepty) {
commtype = XIOCOMM_PTY;
} else if (usepipes) {
commtype = XIOCOMM_PIPES;
}
/*------------------------------------------------------------------------*/
/* retrieve options regarding file descriptors */
if (!retropt_int(popts, OPT_LEFTFD, &fdi)) {
fdo = fdi;
}
retropt_int(popts, OPT_LEFTINFD, &fdi);
retropt_int(popts, OPT_LEFTOUTFD, &fdo);
if (!retropt_int(popts, OPT_RIGHTFD, &rightin)) {
rightout = rightin;
}
retropt_int(popts, OPT_RIGHTINFD, &rightin);
retropt_int(popts, OPT_RIGHTOUTFD, &rightout);
/* when the superordinate communication type provides two distinct fds we
cannot pass just one fd to the program */
if (rw == XIO_RDWR && rightin==rightout) {
struct stat rstat, wstat;
if (Fstat(xfd->rfd, &rstat) < 0)
Error2("fstat(%d, ...): %s", xfd->rfd, strerror(errno));
if (Fstat(xfd->wfd, &wstat) < 0)
Error2("fstat(%d, ...): %s", xfd->wfd, strerror(errno));
if (memcmp(&rstat, &wstat, sizeof(rstat))) {
Error("exec/system: your rightfd options require the same FD for both directions but the communication environment provides two different FDs");
}
}
/*------------------------------------------------------------------------*/
if (rw == XIO_WRONLY) {
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_SLEEP_SIGTERM;
}
}
if (withfork) {
const char *typename;
if (!(xioflags&XIO_MAYCHILD)) {
Error("fork for exec not allowed in this context");
/*!! free something */
return -1;
}
fd->flags |= XIO_DOESCHILD;
switch (commtype) {
case XIOCOMM_PIPES: typename = "pipes"; break;
#if HAVE_PTY
case XIOCOMM_PTY: typename = "pty"; break;
case XIOCOMM_PTYS: typename = "two pty's"; break;
#endif /* HAVE_PTY */
case XIOCOMM_SOCKETPAIR: typename = "socketpair"; break;
case XIOCOMM_SOCKETPAIRS: typename = "two socketpairs"; break;
#if _WITH_TCP
case XIOCOMM_TCP: typename = "TCP socket pair"; break;
case XIOCOMM_TCP4: typename = "TCP4 socket pair"; break;
case XIOCOMM_TCP4_LISTEN: typename = "TCP4 listen socket pair"; break;
#endif
default: typename = NULL; break;
}
Notice2("forking off child, using %s for %s",
typename, ddirection[rw]);
}
applyopts(-1, popts, PH_PREBIGEN);
if (inter) {
saverfd = xfd->rfd;
savewfd = xfd->wfd;
xfd->howtoshut = XIOSHUT_UNSPEC;
xfd->howtoclose = XIOCLOSE_UNSPEC;
}
if (!withfork) {
/*0 struct single *stream1, *stream2;*/
free(*copts);
*copts = moveopts(popts, GROUP_ALL);
/* what if WE are sock1 ? */
#if 1
if (!(xioflags & XIO_MAYEXEC /* means exec+nofork */)) {
Error("nofork option is not allowed here");
/*!! free something */
return -1;
}
fd->flags |= XIO_DOESEXEC;
#else /*!! */
if (sock1 == NULL) {
Fatal("nofork option must no be applied to first socat address");
}
#endif
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_CLOSE;
}
#if 0 /*!! */
if (sock1->tag == XIO_TAG_DUAL) {
stream1 = &sock1->dual.stream[0]->stream;
stream2 = &sock1->dual.stream[1]->stream;
} else {
stream1 = &sock1->stream;
stream2 = &sock1->stream;
}
if (stream1->dtype == DATA_READLINE || stream2->dtype == DATA_READLINE ||
stream1->dtype == DATA_OPENSSL || stream2->dtype == DATA_OPENSSL
) {
Error("with option nofork, openssl and readline in address1 do not work");
}
if (stream1->lineterm != LINETERM_RAW ||
stream2->lineterm != LINETERM_RAW ||
stream1->ignoreeof || stream2->ignoreeof) {
Warn("due to option nofork, address1 options for lineterm and igoreeof do not apply");
}
#endif
/*! problem: when fdi==WRFD(sock[0]) or fdo==RDFD(sock[0]) */
if (rw != XIO_WRONLY) {
if (XIO_GETRDFD(sock[0]/*!!!*/) == fdi) {
if (Fcntl_l(fdi, F_SETFD, 0) < 0) {
Warn2("fcntl(%d, F_SETFD, 0): %s", fdi, strerror(errno));
}
if (Dup2(XIO_GETRDFD(sock[0]), fdi) < 0) {
Error3("dup2(%d, %d): %s",
XIO_GETRDFD(sock[0]), fdi, strerror(errno));
}
/*0 Info2("dup2(%d, %d)", XIO_GETRDFD(sock[0]), fdi);*/
} else {
if (Dup2(XIO_GETRDFD(sock[0]), fdi) < 0) {
Error3("dup2(%d, %d): %s",
XIO_GETRDFD(sock[0]), fdi, strerror(errno));
}
/*0 Info2("dup2(%d, %d)", XIO_GETRDFD(sock[0]), fdi);*/
}
}
if (rw != XIO_RDONLY) {
if (XIO_GETWRFD(sock[0]) == fdo) {
if (Fcntl_l(fdo, F_SETFD, 0) < 0) {
Warn2("fcntl(%d, F_SETFD, 0): %s", fdo, strerror(errno));
}
if (Dup2(XIO_GETWRFD(sock[0]), fdo) < 0) {
Error3("dup2(%d, %d): %s)",
XIO_GETWRFD(sock[0]), fdo, strerror(errno));
}
/*0 Info2("dup2(%d, %d)", XIO_GETWRFD(sock[0]), fdo);*/
} else {
if (Dup2(XIO_GETWRFD(sock[0]), fdo) < 0) {
Error3("dup2(%d, %d): %s)",
XIO_GETWRFD(sock[0]), fdo, strerror(errno));
}
/*0 Info2("dup2(%d, %d)", XIO_GETWRFD(sock[0]), fdo);*/
}
}
} else /* withfork */
/* create fd pair(s), set related xfd parameters, and apply options */
switch (commtype) {
#if HAVE_PTY
case XIOCOMM_PTY:
/*!indent*/
#if defined(HAVE_DEV_PTMX)
# define PTMX "/dev/ptmx" /* Linux */
#elif HAVE_DEV_PTC
# define PTMX "/dev/ptc" /* AIX 4.3.3 */
#endif
fd->dtype = XIODATA_PTY;
#if 0
if (fd->howtoshut == XIOSHUT_UNSPEC) {
fd->howtoshut = XIOSHUTRD_SIGTERM|XIOSHUTWR_SIGHUP;
}
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_CLOSE_SIGTERM;
}
#endif
if (xiopty(usebestpty||useptmx, &ttyfd, &ptyfd) < 0) {
return -1;
}
free(*copts);
if ((*copts = moveopts(popts, GROUP_TERMIOS|GROUP_FORK|GROUP_EXEC|GROUP_PROCESS)) == NULL) {
return -1;
}
applyopts_cloexec(ptyfd, popts);/*!*/
/* exec:...,pty did not kill child process under some circumstances */
if (fd->howtoshut == XIOSHUT_UNSPEC) {
fd->howtoshut = XIOSHUTRD_SIGTERM|XIOSHUTWR_SIGHUP;
}
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_CLOSE_SIGTERM;
}
/* this for parent, was after fork */
applyopts(ptyfd, popts, PH_FD);
applyopts(ptyfd, popts, PH_LATE);
if (applyopts_single(fd, popts, PH_LATE) < 0) return -1;
if (XIOWITHRD(rw)) fd->rfd = ptyfd;
if (XIOWITHWR(rw)) fd->wfd = ptyfd;
/* this for child, was after fork */
applyopts(ttyfd, *copts, PH_FD);
break;
#endif /* HAVE_PTY */
case XIOCOMM_PIPES: {
/*!indent*/
struct opt *popts2, *copts2;
if (rw == XIO_RDWR) {
fd->dtype = XIODATA_2PIPE;
}
if (fd->howtoshut == XIOSHUT_UNSPEC || fd->howtoshut == XIOSHUT_DOWN) {
fd->howtoshut = XIOSHUT_CLOSE;
}
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_CLOSE;
}
if (rw != XIO_WRONLY) {
if (Pipe(rdpip) < 0) {
Error2("pipe(%p): %s", rdpip, strerror(errno));
return -1;
}
}
/*0 Info2("pipe({%d,%d})", rdpip[0], rdpip[1]);*/
/* rdpip[0]: read by socat; rdpip[1]: write by child */
free(*copts);
if ((*copts = moveopts(popts, GROUP_FORK|GROUP_EXEC|GROUP_PROCESS))
== NULL) {
return -1;
}
popts2 = copyopts(popts, GROUP_ALL);
copts2 = copyopts(*copts, GROUP_ALL);
if (rw != XIO_WRONLY) {
applyopts_cloexec(rdpip[0], popts);
applyopts(rdpip[0], popts, PH_FD);
applyopts(rdpip[1], *copts, PH_FD);
}
if (rw != XIO_RDONLY) {
if (Pipe(wrpip) < 0) {
Error2("pipe(%p): %s", wrpip, strerror(errno));
return -1;
}
}
/*0 Info2("pipe({%d,%d})", wrpip[0], wrpip[1]);*/
/* wrpip[1]: write by socat; wrpip[0]: read by child */
if (rw != XIO_RDONLY) {
applyopts_cloexec(wrpip[1], popts2);
applyopts(wrpip[1], popts2, PH_FD);
applyopts(wrpip[0], copts2, PH_FD);
}
/* this for parent, was after fork */
if (XIOWITHRD(rw)) fd->rfd = rdpip[0];
if (XIOWITHWR(rw)) fd->wfd = wrpip[1];
applyopts(fd->rfd, popts, PH_FD);
applyopts(fd->rfd, popts, PH_LATE);
if (applyopts_single(fd, popts, PH_LATE) < 0) return -1;
break;
}
case XIOCOMM_SOCKETPAIR: {
/*!indent*/
int pf = AF_UNIX;
retropt_int(popts, OPT_PROTOCOL_FAMILY, &pf);
result = xiosocketpair(popts, pf, SOCK_STREAM, 0, sv);
if (result < 0) {
return -1;
}
if (xfd->howtoshut == XIOSHUT_UNSPEC) {
xfd->howtoshut = XIOSHUT_DOWN;
}
if (xfd->howtoclose == XIOCLOSE_UNSPEC) {
xfd->howtoclose = XIOCLOSE_CLOSE;
}
/*0 Info5("socketpair(%d, %d, %d, {%d,%d})",
d, type, protocol, sv[0], sv[1]);*/
free(*copts);
if ((*copts = moveopts(popts, GROUP_FORK|GROUP_EXEC|GROUP_PROCESS)) == NULL) {
return -1;
}
applyopts(sv[0], *copts, PH_PASTSOCKET);
applyopts(sv[1], popts, PH_PASTSOCKET);
applyopts_cloexec(sv[0], *copts);
applyopts(sv[0], *copts, PH_FD);
applyopts(sv[1], popts, PH_FD);
applyopts(sv[0], *copts, PH_PREBIND);
applyopts(sv[0], *copts, PH_BIND);
applyopts(sv[0], *copts, PH_PASTBIND);
applyopts(sv[1], popts, PH_PREBIND);
applyopts(sv[1], popts, PH_BIND);
applyopts(sv[1], popts, PH_PASTBIND);
Warn1("xio-progcall.c: fd->howtoshut == %d", fd->howtoshut);
if (inter || fd->howtoshut == XIOSHUT_UNSPEC) {
fd->howtoshut = XIOSHUT_DOWN;
}
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_SIGTERM;
}
/* this for parent, was after fork */
/*!!!*/ Warn2("2: fd->rfd==%d, fd->wfd==%d", fd->rfd, fd->wfd);
if (XIOWITHRD(rw)) fd->rfd = sv[0];
if (XIOWITHWR(rw)) fd->wfd = sv[0];
/*!!!*/ Warn2("3: fd->rfd==%d, fd->wfd==%d", fd->rfd, fd->wfd);
applyopts(fd->rfd, popts, PH_FD);
applyopts(fd->rfd, popts, PH_LATE);
if (applyopts_single(fd, popts, PH_LATE) < 0) return -1;
}
break;
case XIOCOMM_TCP:
case XIOCOMM_TCP4: {
/*!indent*/
int pf = AF_INET;
xiofd_t socatfd, execfd;
retropt_int(popts, OPT_PROTOCOL_FAMILY, &pf);
if (xiocommpair(commtype, XIOWITHWR(rw), XIOWITHRD(rw),
0, &socatfd, &execfd) < 0) {
return -1;
}
free(*copts);
if ((*copts = moveopts(popts, GROUP_FORK|GROUP_EXEC|GROUP_PROCESS)) == NULL) {
return -1;
}
sv[0] = socatfd.rfd; /*!!! r/w */
sv[1] = execfd.wfd;
applyopts(socatfd.rfd, *copts, PH_PASTSOCKET);
applyopts(execfd.rfd, popts, PH_PASTSOCKET);
applyopts_cloexec(sv[0], *copts);
applyopts(sv[0], *copts, PH_FD);
applyopts(sv[1], popts, PH_FD);
applyopts(sv[0], *copts, PH_PREBIND);
applyopts(sv[0], *copts, PH_BIND);
applyopts(sv[0], *copts, PH_PASTBIND);
applyopts(sv[1], popts, PH_PREBIND);
applyopts(sv[1], popts, PH_BIND);
applyopts(sv[1], popts, PH_PASTBIND);
Warn1("xio-progcall.c: fd->howtoshut == %d", fd->howtoshut);
if (inter || fd->howtoshut == XIOSHUT_UNSPEC) {
fd->howtoshut = XIOSHUT_DOWN;
}
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOCLOSE_SIGTERM;
}
/* this for parent, was after fork */
if (XIOWITHRD(rw)) fd->rfd = sv[0];
if (XIOWITHWR(rw)) fd->wfd = sv[0];
applyopts(fd->rfd, popts, PH_FD);
applyopts(fd->rfd, popts, PH_LATE);
if (applyopts_single(fd, popts, PH_LATE) < 0) return -1;
}
break;
#if LATER
case XIOCOMM_TCP4_LISTEN: {
/*!indent*/
int pf = AF_INET;
xiofd_t socatfd, execfd;
retropt_int(popts, OPT_PROTOCOL_FAMILY, &pf);
if (xiocommpair(commtype, XIOWITHWR(rw), XIOWITHRD(rw),
0, &socatfd, &execfd) < 0) {
return -1;
}
free(*copts);
if ((*copts = moveopts(popts, GROUP_TERMIOS|GROUP_FORK|GROUP_EXEC|GROUP_PROCESS)) == NULL) {
return -1;
}
applyopts_cloexec(ptyfd, popts);/*!*/
}
break;
#endif /* LATER */
case XIOCOMM_SOCKETPAIRS:
case XIOCOMM_PTYS: {
xiofd_t socatfd, execfd;
struct termios andmask, ormask;
switch (commtype) {
case XIOCOMM_SOCKETPAIRS:
if (xiocommpair(commtype, XIOWITHWR(rw), XIOWITHRD(rw),
0, &socatfd, &execfd, PF_UNIX, SOCK_STREAM, 0) < 0)
return -1;
break;
case XIOCOMM_PTYS:
if (xiocommpair(commtype, XIOWITHWR(rw), XIOWITHRD(rw),
0, &socatfd, &execfd, &andmask, &ormask) < 0)
return -1;
break;
}
free(*copts);
if ((*copts = copyopts(popts, GROUP_TERMIOS|GROUP_FORK)) == NULL) {
return -1;
}
if (socatfd.rfd >= 0) {
applyopts_cloexec(socatfd.rfd, *copts);/*!*/
applyopts(socatfd.rfd, *copts, PH_FD);
applyopts(socatfd.rfd, *copts, PH_LATE);
}
if (applyopts_single(xfd, *copts, PH_LATE) < 0) return -1;
free(*copts);
if ((*copts = moveopts(popts, GROUP_TERMIOS|GROUP_FORK|GROUP_EXEC|GROUP_PROCESS)) == NULL) {
return -1;
}
if (socatfd.wfd >= 0) {
applyopts_cloexec(socatfd.wfd, *copts);/*!*/
applyopts(socatfd.wfd, *copts, PH_FD);
applyopts(socatfd.wfd, *copts, PH_LATE);
}
if (applyopts_single(xfd, *copts, PH_LATE) < 0) return -1;
if (XIOWITHRD(rw)) xfd->rfd = socatfd.rfd;
if (XIOWITHWR(rw)) xfd->wfd = socatfd.wfd;
xfd->dtype = socatfd.dtype;
if (xfd->howtoshut == XIOSHUT_UNSPEC)
xfd->howtoshut = socatfd.howtoshut;
if (fd->howtoclose == XIOCLOSE_UNSPEC) {
fd->howtoclose = XIOWITHRD(rw)?XIOCLOSE_CLOSE_SIGTERM:XIOCLOSE_SLEEP_SIGTERM;
}
wrpip[0] = execfd.rfd;
rdpip[1] = execfd.wfd;
rdpip[0] = socatfd.rfd;
wrpip[1] = socatfd.wfd;
}
break;
default:
Error1("_xioopen_progcall() internal: commtype %d not handled",
commtype);
break;
}
/*0 if ((optpr = copyopts(*copts, GROUP_PROCESS)) == NULL)
return -1;*/
retropt_bool(*copts, OPT_STDERR, &withstderr);
xiosetchilddied(); /* set SIGCHLD handler */
xiosetchilddied(); /* set SIGCHLD handler */
if (withfork) {
sigset_t set, oldset;
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
Sigprocmask(SIG_BLOCK, &set, &oldset); /* disable SIGCHLD */
pid = xio_fork(true, E_ERROR);
if (pid < 0) {
Sigprocmask(SIG_SETMASK, &oldset, NULL);
Error1("fork(): %s", strerror(errno));
return -1;
}
if (pid > 0) {
/* for parent (this is our socat process) */
xiosigchld_register(pid, xiosigaction_child, fd);
Sigprocmask(SIG_SETMASK, &oldset, NULL); /* enable SIGCHLD */
}
if (pid == 0) { /* child */
/* drop parents locks, reset FIPS... */
if (xio_forked_inchild() != 0) {
Exit(1);
}
Sigprocmask(SIG_SETMASK, &oldset, NULL); /* enable SIGCHLD */
}
}
if (!withfork || pid == 0) { /* child */
uid_t user;
gid_t group;
if (withfork) {
if (Signal(SIGCHLD, SIG_IGN) == SIG_ERR) {
Warn1("signal(SIGCHLD, SIG_IGN): %s", strerror(errno));
}
/* dup2() the fds to desired values, close old fds, and apply late
options */
switch (commtype) {
#if HAVE_PTY
case XIOCOMM_PTY:
if (rw != XIO_RDONLY && fdi != ttyfd) {
if (Dup2(ttyfd, fdi) < 0) {
Error3("dup2(%d, %d): %s", ttyfd, fdi, strerror(errno));
return -1; }
/*0 Info2("dup2(%d, %d)", ttyfd, fdi);*/
}
if (rw != XIO_WRONLY && fdo != ttyfd) {
if (Dup2(ttyfd, fdo) < 0) {
Error3("dup2(%d, %d): %s", ttyfd, fdo, strerror(errno));
return -1; }
/*0 Info2("dup2(%d, %d)", ttyfd, fdo);*/
}
if ((rw == XIO_RDONLY || fdi != ttyfd) &&
(rw == XIO_WRONLY || fdo != ttyfd)) {
applyopts_cloexec(ttyfd, *copts);
}
applyopts(ttyfd, *copts, PH_LATE);
applyopts(ttyfd, *copts, PH_LATE2);
break;
#endif /* HAVE_PTY */
case XIOCOMM_PIPES:
case XIOCOMM_SOCKETPAIRS:
case XIOCOMM_PTYS:
{
/*!indent*/
/* we might have a temporary conflict between what FDs are
currently allocated, and which are to be used. We try to find
a graceful solution via temporary descriptors */
int tmpi, tmpo;
/* needed with system() (not with exec()) */
if (XIOWITHRD(rw)) Close(rdpip[0]);
if (XIOWITHWR(rw)) Close(wrpip[1]);
#if 0
/*! might not be needed */
if (XIOWITHRD(rw)) Close(rdpip[0]);
if (XIOWITHWR(rw)) Close(wrpip[1]);
if (fdi == rdpip[1]) { /* a conflict here */
if ((tmpi = Dup(wrpip[0])) < 0) {
Error2("dup(%d): %s", wrpip[0], strerror(errno));
return -1;
}
/*0 Info2("dup(%d) -> %d", wrpip[0], tmpi);*/
rdpip[1] = tmpi;
}
if (fdo == wrpip[0]) { /* a conflict here */
if ((tmpo = Dup(rdpip[1])) < 0) {
Error2("dup(%d): %s", rdpip[1], strerror(errno));
return -1;
}
/*0 Info2("dup(%d) -> %d", rdpip[1], tmpo);*/
wrpip[0] = tmpo;
}
if (rw != XIO_WRONLY && rdpip[1] != fdo) {
if (Dup2(rdpip[1], fdo) < 0) {
Error3("dup2(%d, %d): %s", rdpip[1], fdo, strerror(errno));
return -1;
}
Close(rdpip[1]);
/*0 Info2("dup2(%d, %d)", rdpip[1], fdo);*/
/*0 applyopts_cloexec(fdo, *copts);*/
}
if (rw != XIO_RDONLY && wrpip[0] != fdi) {
if (Dup2(wrpip[0], fdi) < 0) {
Error3("dup2(%d, %d): %s", wrpip[0], fdi, strerror(errno));
return -1;
}
Close(wrpip[0]);
/*0 Info2("dup2(%d, %d)", wrpip[0], fdi);*/
/*0 applyopts_cloexec(wrpip[0], *copts);*/ /* option is already consumed! */
/* applyopts_cloexec(fdi, *copts);*/ /* option is already consumed! */
}
#else
result = reassignfds(XIOWITHWR(rw)?wrpip[0]:-1,
XIOWITHRD(rw)?rdpip[1]:-1,
fdi, fdo);
if (result < 0) return result;
#endif
applyopts(fdi, *copts, PH_LATE);
applyopts(fdo, *copts, PH_LATE);
applyopts(fdi, *copts, PH_LATE2);
applyopts(fdo, *copts, PH_LATE2);
break;
}
case XIOCOMM_SOCKETPAIR:
case XIOCOMM_TCP:
case XIOCOMM_TCP4:
case XIOCOMM_TCP4_LISTEN:
/*!indent*/
if (rw != XIO_RDONLY && fdi != sv[1]) {
if (Dup2(sv[1], fdi) < 0) {
Error3("dup2(%d, %d): %s", sv[1], fdi, strerror(errno));
return -1; }
/*0 Info2("dup2(%d, %d)", sv[1], fdi);*/
}
if (rw != XIO_WRONLY && fdo != sv[1]) {
if (Dup2(sv[1], fdo) < 0) {
Error3("dup2(%d, %d): %s", sv[1], fdo, strerror(errno));
return -1; }
/*0 Info2("dup2(%d, %d)", sv[1], fdo);*/
}
if (fdi != sv[1] && fdo != sv[1]) {
applyopts_cloexec(sv[1], *copts);
Close(sv[1]);
}
applyopts(fdi, *copts, PH_LATE);
applyopts(fdi, *copts, PH_LATE2);
Close(sv[1]);
break;
default:
Error1("_xioopen_progcall() internal: commtype %d not handled",
commtype);
break;
}
/* in case of an inter address, assign the right side FDs (e.g. 3 and 4) */
if (inter) {
Info2("preparing the right side FDs %d and %d for exec process",
rightin, rightout);
result = reassignfds(XIOWITHRD(rw)?saverfd:-1,
XIOWITHWR(rw)?savewfd:-1,
rightin, form==2?rightout:STDOUT_FILENO);
if (result < 0) return result;
if (form == 2) {
Fcntl_l(rightin, F_SETFD, 0);
Fcntl_l(rightout, F_SETFD, 0);
}
}
} /* withfork */
else /* !withfork */ {
applyopts(-1, *copts, PH_LATE);
applyopts(-1, *copts, PH_LATE2);
}
_xioopen_setdelayeduser();
/* set group before user - maybe you are not permitted afterwards */
if (retropt_gidt(*copts, OPT_SETGID, &group) >= 0) {
Setgid(group);
}
if (retropt_uidt(*copts, OPT_SETUID, &user) >= 0) {
Setuid(user);
}
if (withstderr) {
*duptostderr = fdo;
} else {
*duptostderr = -1;
}
return 0; /* indicate child process */
}
/* for parent (this is our socat process) */
Notice1("forked off child process "F_pid, pid);
#if 0
if ((popts = copyopts(*copts,
GROUP_FD|GROUP_TERMIOS|GROUP_FORK|GROUP_SOCKET|GROUP_SOCK_UNIX|GROUP_FIFO)) == NULL)
return STAT_RETRYLATER;
#endif
/* in parent: close fds that are only needed in child */
switch (commtype) {
#if HAVE_PTY
case XIOCOMM_PTY:
if (Close(ttyfd) < 0) {
Info2("close(%d): %s", ttyfd, strerror(errno));
}
break;
#endif /* HAVE_PTY */
case XIOCOMM_SOCKETPAIR:
case XIOCOMM_TCP:
case XIOCOMM_TCP4:
case XIOCOMM_TCP4_LISTEN:
Close(sv[1]);
break;
case XIOCOMM_PIPES:
default:
if (XIOWITHWR(rw)) Close(wrpip[0]);
if (XIOWITHRD(rw)) Close(rdpip[1]);
break;
}
fd->child.pid = pid;
if (applyopts_single(fd, popts, PH_LATE) < 0) return -1;
applyopts_signal(fd, popts);
if ((numleft = leftopts(popts)) > 0) {
Error1("%d option(s) could not be used", numleft);
showleft(popts);
return STAT_NORETRY;
}
if (inter) {
if (XIOWITHRD(rw)) Close(saverfd);
if (XIOWITHWR(rw)) Close(savewfd);
}
return pid; /* indicate parent (main) process */
}
/* analyze a file descriptor */
int filan_fd(int fd, FILE *outfile) {
#if HAVE_STAT64
struct stat64 buf = {0};
#else
struct stat buf = {0};
#endif /* !HAVE_STAT64 */
int result;
Debug1("checking file descriptor %u", fd);
#if HAVE_STAT64
result = Fstat64(fd, &buf);
#else
result = Fstat(fd, &buf);
#endif /* !HAVE_STAT64 */
if (result < 0) {
if (errno == EBADF) {
Debug2("fstat(%d): %s", fd, strerror(errno));
} else {
Warn2("fstat(%d): %s", fd, strerror(errno));
}
return -1;
}
Debug2("fd %d is a %s", fd, getfiletypestring(buf.st_mode));
result = filan_stat(&buf, fd, fd, outfile);
if (result >= 0) {
/* even more dynamic info */
{ /* see if data is available */
struct pollfd ufds;
ufds.fd = fd;
ufds.events = POLLIN|POLLPRI|POLLOUT
#ifdef POLLRDNORM
|POLLRDNORM
#endif
#ifdef POLLRDBAND
|POLLRDBAND
#endif
|POLLWRNORM
#ifdef POLLWRBAND
|POLLWRBAND
#endif
#ifdef POLLMSG
|POLLMSG
#endif
;
if (Poll(&ufds, 1, 0) < 0) {
Warn4("poll({%d, %hd, %hd}, 1, 0): %s",
ufds.fd, ufds.events, ufds.revents, strerror(errno));
} else {
fputs("poll: ", outfile);
if (ufds.revents & POLLIN) fputs("IN,", outfile);
if (ufds.revents & POLLPRI) fputs("PRI,", outfile);
if (ufds.revents & POLLOUT) fputs("OUT,", outfile);
if (ufds.revents & POLLERR) fputs("ERR,", outfile);
if (ufds.revents & POLLNVAL) fputs("NVAL,", outfile);
#ifdef FIONREAD
if (ufds.revents & POLLIN) {
size_t sizet;
if ((result = Ioctl(fd, FIONREAD, &sizet) >= 0)) {
fprintf (outfile, "; FIONREAD="F_Zu, sizet);
}
}
#endif /* defined(FIONREAD) */
#if _WITH_SOCKET && defined(MSG_DONTWAIT)
if ((ufds.revents & POLLIN) && isasocket(fd)) {
char _peername[SOCKADDR_MAX];
struct sockaddr *pa = (struct sockaddr *)_peername;
struct msghdr msgh = {0};
char peekbuff[1]; /* [0] fails with some compilers */
#if HAVE_STRUCT_IOVEC
struct iovec iovec;
#endif
char ctrlbuff[5120];
ssize_t bytes;
fputs("; ", outfile);
msgh.msg_name = pa;
msgh.msg_namelen = sizeof(*pa);
#if HAVE_STRUCT_IOVEC
iovec.iov_base = peekbuff;
iovec.iov_len = sizeof(peekbuff);
msgh.msg_iov = &iovec;
msgh.msg_iovlen = 1;
#endif
#if HAVE_STRUCT_MSGHDR_MSGCONTROL
msgh.msg_control = ctrlbuff;
#endif
#if HAVE_STRUCT_MSGHDR_MSGCONTROLLEN
msgh.msg_controllen = sizeof(ctrlbuff);
#endif
#if HAVE_STRUCT_MSGHDR_MSGFLAGS
msgh.msg_flags = 0;
#endif
if ((bytes = Recvmsg(fd, &msgh, MSG_PEEK|MSG_DONTWAIT)) < 0) {
Warn1("recvmsg(): %s", strerror(errno));
} else {
fprintf(outfile, "recvmsg="F_Zd", ", bytes);
}
}
#endif /* _WITH_SOCKET && defined(MSG_DONTWAIT) */
}
}
}
fputc('\n', outfile);
return 0;
}
int rpmiobSlurp(const char * fn, rpmiob * iobp)
{
static size_t blenmax = (128 * BUFSIZ); /* XXX 1Mb with glibc */
rpmuint8_t * b = NULL;
size_t blen = 0;
struct stat sb;
FD_t fd;
int rc = 0;
int xx;
fd = Fopen(fn, "r.ufdio");
if (fd == NULL || Ferror(fd)) {
rc = 2;
goto exit;
}
sb.st_size = 0;
if ((xx = Fstat(fd, &sb)) < 0 || sb.st_size == 0)
sb.st_size = blenmax;
#if defined(__linux__)
/* XXX st->st_size = 0 for /proc files on linux, see stat(2). */
/* XXX glibc mmap'd libio no workie for /proc files on linux?!? */
if (sb.st_size == 0 && !strncmp(fn, "/proc/", sizeof("/proc/")-1)) {
blen = blenmax;
b = xmalloc(blen+1);
b[0] = (rpmuint8_t) '\0';
xx = read(Fileno(fd), b, blen);
blen = (size_t) (xx >= 0 ? xx : 0);
} else
#endif
{
blen = sb.st_size;
b = xmalloc(blen+1);
b[0] = (rpmuint8_t) '\0';
blen = Fread(b, sizeof(*b), blen, fd);
if (Ferror(fd)) {
rc = 1;
goto exit;
}
}
if (blen < (size_t)sb.st_size)
b = xrealloc(b, blen+1);
b[blen] = (rpmuint8_t) '\0';
exit:
if (fd != NULL) (void) Fclose(fd);
if (rc == 0) {
if (iobp != NULL) {
/* XXX use rpmiobNew() if/when lazy iop->b alloc is implemented. */
rpmiob iob = rpmiobGetPool(_rpmiobPool);
iob->b = b;
iob->blen = blen;
iob->allocated = blen;
*iobp = iob;
}
} else {
if (iobp)
*iobp = NULL;
b = _free(b);
}
return rc;
}
