ATF_TC_BODY(rfork, tc)
{
struct stat sb;
struct lwp *l, *l2;
int fd;
RZ(rump_init());
ATF_REQUIRE_EQ(rump_pub_lwproc_rfork(RUMP_RFFDG|RUMP_RFCFDG), EINVAL);
RZ(rump_pub_lwproc_rfork(0));
l = rump_pub_lwproc_curlwp();
RL(fd = rump_sys_open("/file", O_RDWR | O_CREAT, 0777));
/* ok, first check rfork(RUMP_RFCFDG) does *not* preserve fd's */
RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
ATF_REQUIRE_ERRNO(EBADF, rump_sys_write(fd, &fd, sizeof(fd)) == -1);
/* then check that rfork(0) does */
rump_pub_lwproc_switch(l);
RZ(rump_pub_lwproc_rfork(0));
ATF_REQUIRE_EQ(rump_sys_write(fd, &fd, sizeof(fd)), sizeof(fd));
RL(rump_sys_fstat(fd, &sb));
l2 = rump_pub_lwproc_curlwp();
/*
* check that the shared fd table is really shared by
* closing fd in parent
*/
rump_pub_lwproc_switch(l);
RL(rump_sys_close(fd));
rump_pub_lwproc_switch(l2);
ATF_REQUIRE_ERRNO(EBADF, rump_sys_fstat(fd, &sb) == -1);
/* redo, this time copying the fd table instead of sharing it */
rump_pub_lwproc_releaselwp();
rump_pub_lwproc_switch(l);
RL(fd = rump_sys_open("/file", O_RDWR, 0777));
RZ(rump_pub_lwproc_rfork(RUMP_RFFDG));
ATF_REQUIRE_EQ(rump_sys_write(fd, &fd, sizeof(fd)), sizeof(fd));
RL(rump_sys_fstat(fd, &sb));
l2 = rump_pub_lwproc_curlwp();
/* check that the fd table is copied */
rump_pub_lwproc_switch(l);
RL(rump_sys_close(fd));
rump_pub_lwproc_switch(l2);
RL(rump_sys_fstat(fd, &sb));
ATF_REQUIRE_EQ(sb.st_size, sizeof(fd));
}
static void
read_after_unlink(const atf_tc_t *tc, const char *mp)
{
char buf[TBSIZE], buf2[TBSIZE];
int fd;
FSTEST_ENTER();
/* create file and put some content into it */
RL(fd = rump_sys_open("file", O_RDWR|O_CREAT, 0666));
memset(buf, 'D', TBSIZE);
ATF_REQUIRE_EQ(rump_sys_write(fd, buf, TBSIZE), TBSIZE);
rump_sys_close(fd);
/* flush buffers from UBC to file system */
ATF_REQUIRE_ERRNO(EBUSY, rump_sys_unmount(mp, 0) == -1);
RL(fd = rump_sys_open("file", O_RDWR));
RL(rump_sys_unlink("file"));
ATF_REQUIRE_EQ(rump_sys_read(fd, buf2, TBSIZE), TBSIZE);
ATF_REQUIRE_EQ(memcmp(buf, buf2, TBSIZE), 0);
rump_sys_close(fd);
FSTEST_EXIT();
}
ATF_TC_BODY(devnull2, tc)
{
struct union_args unionargs;
int fd, res;
rump_init();
if (rump_sys_mkdir("/mp", 0777) == -1)
atf_tc_fail_errno("mkdir mp");
unionargs.target = __UNCONST("/dev");
unionargs.mntflags = UNMNT_BELOW;
if (rump_sys_mount(MOUNT_UNION, "/mp", 0,
&unionargs, sizeof(unionargs)) == -1)
atf_tc_fail_errno("union mount");
fd = rump_sys_open("/mp/null", O_WRONLY | O_CREAT | O_APPEND);
if (fd == -1)
atf_tc_fail_errno("open");
res = rump_sys_write(fd, &fd, sizeof(fd));
if (res != sizeof(fd))
atf_tc_fail("write");
}
int
main()
{
struct sockaddr_in sin;
char buf[65535];
struct hostent *hp;
ssize_t nn;
ssize_t off;
int s, e;
hp = gethostbyname(DESTHOST);
if (!hp || hp->h_addrtype != AF_INET)
errx(1, "failed to resolve \"%s\"", DESTHOST);
rump_init();
#ifndef USE_SOCKIN
if ((e = rump_pub_netconfig_ifcreate("virt0")) != 0)
die(e, "create virt0");
if ((e = rump_pub_netconfig_dhcp_ipv4_oneshot("virt0")) != 0)
die(e, "dhcp address");
#endif
s = rump_sys_socket(PF_INET, SOCK_STREAM, 0);
if (s == -1)
die(errno, "socket");
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
#if 0
sin.sin_len = sizeof(sin);
#endif
sin.sin_port = htons(80);
memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
if (rump_sys_connect(s, (struct sockaddr *)&sin, sizeof(sin)) == -1)
die(errno, "connect");
printf("connected\n");
#define WANTHTML "GET / HTTP/1.1\nHost: www.netbsd.org\n\n"
nn = rump_sys_write(s, WANTHTML, sizeof(WANTHTML)-1);
printf("write rv %zd\n", nn);
for (;;) {
nn = rump_sys_read(s, buf, sizeof(buf)-1);
if (nn == -1)
die(errno, "read failed");
if (nn == 0)
break;
buf[nn] = '\0';
printf("%s", buf);
}
rump_sys_close(s);
die(0, NULL);
}
static void
overwritebody(const atf_tc_t *tc, off_t count, bool dotrunc)
{
char *buf;
int fd;
REQUIRE_LIBC(buf = malloc(count), NULL);
FSTEST_ENTER();
RL(fd = rump_sys_open("testi", O_CREAT | O_RDWR, 0666));
ATF_REQUIRE_EQ(rump_sys_write(fd, buf, count), count);
RL(rump_sys_close(fd));
RL(fd = rump_sys_open("testi", O_RDWR));
if (dotrunc)
RL(rump_sys_ftruncate(fd, 0));
ATF_REQUIRE_EQ(rump_sys_write(fd, buf, count), count);
RL(rump_sys_close(fd));
FSTEST_EXIT();
}
/*
* Prepare rump, configure interface and route to cause fragmentation
*/
static void
setup(void)
{
char ifname[IFNAMSIZ];
struct {
struct rt_msghdr m_rtm;
struct sockaddr_in m_sin;
} m_rtmsg;
#define rtm m_rtmsg.m_rtm
#define rsin m_rtmsg.m_sin
struct ifreq ifr;
int s;
rump_init();
/* first, config lo0 & route */
strcpy(ifname, "lo0");
netcfg_rump_if(ifname, "127.0.0.1", "255.0.0.0");
netcfg_rump_route("127.0.0.1", "255.0.0.0", "127.0.0.1");
if ((s = rump_sys_socket(PF_ROUTE, SOCK_RAW, 0)) == -1)
atf_tc_fail_errno("routing socket");
/*
* set MTU for interface so that route MTU doesn't
* get overridden by it.
*/
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, "lo0");
ifr.ifr_mtu = 1300;
if (rump_sys_ioctl(s, SIOCSIFMTU, &ifr) == -1)
atf_tc_fail_errno("set mtu");
/* change route MTU to 100 */
memset(&m_rtmsg, 0, sizeof(m_rtmsg));
rtm.rtm_type = RTM_CHANGE;
rtm.rtm_flags = RTF_STATIC;
rtm.rtm_version = RTM_VERSION;
rtm.rtm_seq = 3;
rtm.rtm_inits = RTV_MTU;
rtm.rtm_addrs = RTA_DST;
rtm.rtm_rmx.rmx_mtu = 100;
rtm.rtm_msglen = sizeof(m_rtmsg);
memset(&rsin, 0, sizeof(rsin));
rsin.sin_family = AF_INET;
rsin.sin_len = sizeof(rsin);
rsin.sin_addr.s_addr = inet_addr("127.0.0.1");
if (rump_sys_write(s, &m_rtmsg, sizeof(m_rtmsg)) != sizeof(m_rtmsg))
atf_tc_fail_errno("set route mtu");
rump_sys_close(s);
}
int netconnect()
{
struct sockaddr_in sin;
char *buf;
ssize_t nn, off;
int error;
int s;
s = rump_sys_socket(PF_INET, SOCK_STREAM, 0);
if (s == -1) {
printf("you're mean! no sucket for you!\n");
return -1;
}
printf("!!!\nTHE FD value: %d\n!!!\n", s);
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(80);
sin.sin_addr.s_addr = DESTADDR;
if (rump_sys_connect(s, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
printf("could not connect\n");
return -1;
}
nn = rump_sys_write(s, WANTHTML, sizeof(WANTHTML)-1);
printf("wrote http request, rv %zd\n", nn);
buf = calloc(1, BUFSIZE);
off = 0;
do {
nn = rump_sys_read(s, buf+off, (BUFSIZE-off)-1);
off += nn;
if (off >= BUFSIZE) exit(-1);
} while (nn > 0);
if (nn == -1) {
printf("read failed: %zd\n", nn);
return -1;
}
printf("read %zd bytes\n", off);
/* display last 500 bytes of delicious info */
buf[off] = '\0';
off -= 500;
if (off < 0)
off = 0;
printf("that was an educational experience. "
"we learned:\n");
printf("%s", &buf[off]);
}
static void
read_fault(const atf_tc_t *tc, const char *mp)
{
char ch = 123;
int fd;
FSTEST_ENTER();
RL(fd = rump_sys_open("file", O_CREAT | O_RDWR, 0777));
ATF_REQUIRE_EQ(rump_sys_write(fd, &ch, 1), 1);
RL(rump_sys_close(fd));
RL(fd = rump_sys_open("file", O_RDONLY | O_SYNC | O_RSYNC));
ATF_REQUIRE_ERRNO(EFAULT, rump_sys_read(fd, NULL, 1) == -1);
RL(rump_sys_close(fd));
FSTEST_EXIT();
}
ATF_TC_BODY(reregister_reg, tc)
{
char buf[1024];
int localfd, etcfd;
ssize_t n;
int tfd;
etcfd = open("/etc/passwd", O_RDONLY);
ATF_REQUIRE(etcfd != -1);
localfd = open("./testfile", O_RDWR | O_CREAT, 0666);
ATF_REQUIRE(localfd != -1);
ATF_REQUIRE_EQ(write(localfd, TESTSTR1, TESTSTR1SZ), TESTSTR1SZ);
/* testfile now contains test string */
rump_init();
ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "/etc/passwd",
RUMP_ETFS_REG), 0);
tfd = rump_sys_open(TESTPATH1, O_RDONLY);
ATF_REQUIRE(tfd != -1);
ATF_REQUIRE(rump_sys_read(tfd, buf, sizeof(buf)) > 0);
rump_sys_close(tfd);
rump_pub_etfs_remove(TESTPATH1);
ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./testfile",
RUMP_ETFS_REG), 0);
tfd = rump_sys_open(TESTPATH2, O_RDWR);
ATF_REQUIRE(tfd != -1);
memset(buf, 0, sizeof(buf));
ATF_REQUIRE((n = rump_sys_read(tfd, buf, sizeof(buf))) > 0);
/* check that we have what we expected */
ATF_REQUIRE_STREQ(buf, TESTSTR1);
/* ... while here, check that writing works too */
ATF_REQUIRE_EQ(rump_sys_lseek(tfd, 0, SEEK_SET), 0);
ATF_REQUIRE(TESTSTR1SZ <= TESTSTR2SZ);
ATF_REQUIRE_EQ(rump_sys_write(tfd, TESTSTR2, TESTSTR2SZ), TESTSTR2SZ);
memset(buf, 0, sizeof(buf));
ATF_REQUIRE_EQ(lseek(localfd, 0, SEEK_SET), 0);
ATF_REQUIRE(read(localfd, buf, sizeof(buf)) > 0);
ATF_REQUIRE_STREQ(buf, TESTSTR2);
close(etcfd);
close(localfd);
}
int
main(int argc, char *argv[])
{
char buf[8192];
ssize_t n;
int probeonly = 0;
int fd_src, fd_dst;
if (argc != 2)
errx(1, "need 2 args");
if (strcmp(argv[1], "probe") == 0)
probeonly = 1;
if (probeonly)
rump_boot_sethowto(RUMP_AB_VERBOSE);
rump_init();
if (probeonly)
exit(0);
fd_dst = rump_sys_open("/dev/ulpt0", O_RDWR);
if (fd_dst == -1)
err(1, "printer open");
fd_src = open(argv[1], O_RDONLY);
if (fd_src == -1)
err(1, "open source");
for (;;) {
n = read(fd_src, buf, sizeof(buf));
if (n == 0)
break;
if (n == -1)
err(1, "read");
if (rump_sys_write(fd_dst, buf, n) != n)
err(1, "write to printer");
}
rump_sys_close(fd_dst);
printf("done\n");
}
ATF_TC_BODY(bpfwriteleak, tc)
{
char buf[28]; /* sizeof(garbage) > etherhdrlen */
struct ifreq ifr;
int ifnum, bpfd;
RZ(rump_init());
RZ(rump_pub_shmif_create(NULL, &ifnum));
sprintf(ifr.ifr_name, "shmif%d", ifnum);
RL(bpfd = rump_sys_open("/dev/bpf", O_RDWR));
RL(rump_sys_ioctl(bpfd, BIOCSETIF, &ifr));
RL(rump_sys_ioctl(bpfd, BIOCSFEEDBACK, &ifr));
if (getmtdata() != 0)
atf_tc_fail("test precondition failed: MT_DATA mbufs != 0");
ATF_REQUIRE_ERRNO(ENETDOWN, rump_sys_write(bpfd, buf, sizeof(buf))==-1);
ATF_REQUIRE_EQ(getmtdata(), 0);
}
static void
extendbody(const atf_tc_t *tc, off_t seekcnt)
{
char buf[TESTSZ+1];
struct stat sb;
int fd;
FSTEST_ENTER();
RL(fd = rump_sys_open("testfile",
O_CREAT | O_RDWR | (seekcnt ? O_APPEND : 0)));
RL(rump_sys_ftruncate(fd, seekcnt));
RL(rump_sys_fstat(fd, &sb));
ATF_REQUIRE_EQ(sb.st_size, seekcnt);
ATF_REQUIRE_EQ(rump_sys_write(fd, TESTSTR, TESTSZ), TESTSZ);
ATF_REQUIRE_EQ(rump_sys_pread(fd, buf, TESTSZ, seekcnt), TESTSZ);
ATF_REQUIRE_STREQ(buf, TESTSTR);
RL(rump_sys_fstat(fd, &sb));
ATF_REQUIRE_EQ(sb.st_size, (off_t)TESTSZ + seekcnt);
RL(rump_sys_close(fd));
FSTEST_EXIT();
}
/* write to trivfs */
kern_return_t
trivfs_S_io_write (trivfs_protid_t cred,
mach_port_t reply, mach_msg_type_name_t reply_type,
char * data, mach_msg_type_number_t data_len,
loff_t offs, mach_msg_type_number_t *amount)
{
if (!cred) {
return EOPNOTSUPP;
} else if (! (cred->po->openmodes & O_WRITE)) {
return EBADF;
}
debug("write %d bytes", data_len);
int sent = rump_sys_write(audio_fd, (char *) data, data_len);
if (sent < 0) {
err("rump_sys_write: %s", rump_strerror(errno));
return EIO;
}
*amount = sent;
return 0;
}
static ssize_t
writestr(int fd, const char *str)
{
return rump_sys_write(fd, str, bmk_strlen(str));
}
int
copy_file(FTSENT *entp, int dne)
{
static unsigned char buf[MAXBSIZE];
struct stat to_stat, *fs;
int ch, checkch, rv, rcount, rval, tolnk, wcount, fdin, fdout;
off_t off;
fs = entp->fts_statp;
tolnk = ((Rflag && !(Lflag || Hflag)) || Pflag);
/*
* If the file exists and we're interactive, verify with the user.
* If the file DNE, set the mode to be the from file, minus setuid
* bits, modified by the umask; arguably wrong, but it makes copying
* executables work right and it's been that way forever. (The
* other choice is 666 or'ed with the execute bits on the from file
* modified by the umask.)
*/
if (!dne) {
if (iflag) {
(void)fprintf(stderr, "overwrite %s? ", to.p_path);
checkch = ch = getchar();
while (ch != '\n' && ch != EOF)
ch = getchar();
if (checkch != 'y' && checkch != 'Y')
return (0);
}
rump_sys_unlink(to.p_path);
}
rv = rump_sys_open(to.p_path, fs->st_mode & ~(S_ISUID | S_ISGID));
if (rv == -1 && (fflag || tolnk)) {
/*
* attempt to remove existing destination file name and
* create a new file
*/
rump_sys_unlink(to.p_path);
rv = rump_sys_open(to.p_path,
fs->st_mode & ~(S_ISUID | S_ISGID));
if (rv == -1) {
warn("%s", to.p_path);
return (1);
}
}
fdout = rv;
fdin = rump_sys_open(entp->fts_path, O_RDONLY);
rval = 0;
/*
* There's no reason to do anything other than close the file
* now if it's empty, so let's not bother.
*/
off = 0;
if (fs->st_size > 0) {
while ((rcount = rump_sys_read(fdin, buf, MAXBSIZE)) > 0) {
wcount = rump_sys_write(fdout, buf, (size_t)rcount);
if (rcount != wcount || wcount == -1) {
warn("%s", to.p_path);
rval = 1;
break;
}
off += rcount;
}
if (rcount < 0) {
warn("%s", entp->fts_path);
rval = 1;
}
}
if (rval == 1)
return (1);
if (pflag && setfile(fs, 0))
rval = 1;
/*
* If the source was setuid or setgid, lose the bits unless the
* copy is owned by the same user and group.
*/
#define RETAINBITS \
(S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
if (!pflag && dne
&& fs->st_mode & (S_ISUID | S_ISGID) && fs->st_uid == myuid) {
if (rump_sys_stat(to.p_path, &to_stat)) {
warn("%s", to.p_path);
rval = 1;
} else if (fs->st_gid == to_stat.st_gid &&
rump_sys_chmod(to.p_path,
fs->st_mode & RETAINBITS & ~myumask)) {
warn("%s", to.p_path);
rval = 1;
}
}
/* set the mod/access times now after close of the fd */
if (pflag && set_utimes(to.p_path, fs)) {
rval = 1;
}
return (rval);
}