示例#1
0
文件: t_etfs.c 项目: 2asoft/freebsd
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);
}
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();
}
示例#3
0
文件: t_etfs.c 项目: 2asoft/freebsd
ATF_TC_BODY(range_blk, tc)
{
	char buf[32000];
	char cmpbuf[32000];
	ssize_t n;
	int rv, tfd;

	/* create a 64000 byte file with 16 1's at offset = 32000 */
	rv = system("dd if=/dev/zero of=disk.img bs=1000 count=64");
	ATF_REQUIRE_EQ(rv, 0);
	rv = system("yes | tr '\\ny' '\\1' "
	    "| dd of=disk.img conv=notrunc bs=1 count=16 seek=32000");
	ATF_REQUIRE_EQ(rv, 0);

	/* map the file at [16000,48000].  this puts our 1's at offset 16000 */
	rump_init();
	ATF_REQUIRE_EQ(rump_pub_etfs_register_withsize(TESTPATH1, "disk.img",
	    RUMP_ETFS_BLK, 16000, 32000), 0);
	tfd = rump_sys_open(TESTPATH1, O_RDWR);
	ATF_REQUIRE(tfd != -1);
	n = rump_sys_read(tfd, buf, sizeof(buf));
	ATF_REQUIRE_EQ(n, sizeof(buf));
	ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
	ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0);

	/* check that we got what is expected */
	memset(cmpbuf, 0, sizeof(cmpbuf));
	memset(cmpbuf+16000, 1, 16);
	ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, sizeof(buf)), 0);
}
示例#4
0
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);
}
示例#5
0
文件: t_etfs.c 项目: 2asoft/freebsd
ATF_TC_BODY(reregister_blk, tc)
{
	char buf[512 * 128];
	char cmpbuf[512 * 128];
	int rv, tfd;

	/* first, create some image files */
	rv = system("dd if=/dev/zero bs=512 count=64 "
	    "| tr '\\0' '\\1' > disk1.img");
	ATF_REQUIRE_EQ(rv, 0);

	rv = system("dd if=/dev/zero bs=512 count=128 "
	    "| tr '\\0' '\\2' > disk2.img");
	ATF_REQUIRE_EQ(rv, 0);

	rump_init();

	ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH1, "./disk1.img",
	    RUMP_ETFS_BLK), 0);
	tfd = rump_sys_open(TESTPATH1, O_RDONLY);
	ATF_REQUIRE(tfd != -1);
	ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 64*512);
	memset(cmpbuf, 1, sizeof(cmpbuf));
	ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 64*512), 0);
	ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
	ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0);

	ATF_REQUIRE_EQ(rump_pub_etfs_register(TESTPATH2, "./disk2.img",
	    RUMP_ETFS_BLK), 0);
	tfd = rump_sys_open(TESTPATH2, O_RDONLY);
	ATF_REQUIRE(tfd != -1);
	ATF_REQUIRE_EQ(rump_sys_read(tfd, buf, sizeof(buf)), 128*512);
	memset(cmpbuf, 2, sizeof(cmpbuf));
	ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, 128*512), 0);
	ATF_REQUIRE_EQ(rump_sys_close(tfd), 0);
	ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH2), 0);
}
示例#6
0
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();
}
示例#8
0
int
main(int argc, char *argv[])
{
	struct wscons_event *wev;
	int shift = 0;
	char buf[128];
	int fd;

	rump_boot_sethowto(RUMP_AB_VERBOSE);
	rump_init();

	fd = rump_sys_open("/dev/wskbd", 0);
	if (fd == -1)
		err(1, "open");

	while (rump_sys_read(fd, buf, sizeof(buf)) > 0) {
		const char *typestr;

		/* XXX: timespec in 5.0 vs. -current */
		wev = (void *)buf;

		switch (wev->type) {
		case WSCONS_EVENT_KEY_UP:
			typestr = "up";
			if (wev->value == 0xe1 || wev->value == 0xe5)
				shift = 0;
			break;
		case WSCONS_EVENT_KEY_DOWN:
			typestr = "down";
			if (wev->value == 0xe1 || wev->value == 0xe5)
				shift = SHIFT;
			break;
		default:
			typestr = "unknown";
			break;
		}
		printf("event type: %d (%s)\n", wev->type, typestr);
		printf("value 0x%x", wev->value);
		/*
		 * There's probably a value-to-readable tool somewhere
		 * in the tree, but i'm not sure where or how to use it,
		 * so I'll just punt with the supersimple version for now.
		 */
		if (wev->value >= 0x04 && wev->value <= 0x1d)
			printf(" (%c)", wev->value - 0x04 + 'a' + shift);
		printf("\n");
	}
}
示例#9
0
int
main(int argc, char *argv[])
{
	struct rump_ufs_args args;
	char imgpath[MAXPATHLEN+1];
	union u u;
	char buf[8192];
	int fd;

	/*
	 * the driver doesn't support endian swapping, so pick image
	 * with matching endianness.
	 */
	u.i = 0x12345678;
	if (u.c == 0x12) {
		snprintf(imgpath, sizeof(imgpath),
		    "%s/%s", argv[1], "sysvbfs_be.img");
	} else {
		snprintf(imgpath, sizeof(imgpath),
		    "%s/%s", argv[1], "sysvbfs_le.img");
	}
		

        rump_init();

#define MYFSDEV "/de-vice"
	rump_pub_etfs_register(MYFSDEV, imgpath, RUMP_ETFS_BLK);
	args.fspec =  (void *)(uintptr_t)MYFSDEV;

	if (rump_sys_mkdir("/mnt", 0755) == -1)
		die("mkdir /mnt");
	if (rump_sys_mount(RUMP_MOUNT_SYSVBFS, "/mnt", RUMP_MNT_RDONLY,
	    &args, sizeof(args)) == -1)
		die("mount");
	if ((fd = rump_sys_open("/mnt/README", 0)) == -1)
		die("open file");
	memset(buf, 0, sizeof(buf));
	if (rump_sys_read(fd, buf, sizeof(buf)) <= 0)
		die("read version");
	if (strcmp(buf, EXPECTED) != 0)
		die("got unexpected result");
	rump_sys_close(fd);
	if (rump_sys_unmount("/mnt", 0) == -1)
		die("unmount failed");

	return 0;
}
示例#10
0
static void
read_directory(const atf_tc_t *tc, const char *mp)
{
	char buf[1024];
	int fd, res;
	ssize_t size;

	FSTEST_ENTER();
	fd = rump_sys_open(".", O_DIRECTORY | O_RDONLY, 0777);
	ATF_REQUIRE(fd != -1);

	size = rump_sys_pread(fd, buf, sizeof(buf), 0);
	ATF_CHECK(size != -1 || errno == EISDIR);
	size = rump_sys_read(fd, buf, sizeof(buf));
	ATF_CHECK(size != -1 || errno == EISDIR);

	res = rump_sys_close(fd);
	ATF_REQUIRE(res != -1);
	FSTEST_EXIT();
}
示例#11
0
int
main()
{
	char buf[8192];
	int fd;

        rump_init();
	if (rump_sys_mkdir("/kern", 0755) == -1)
		die("mkdir /kern");
	if (rump_sys_mount("kernfs", "/kern", 0, NULL, 0) == -1)
		die("mount kernfs");
	if ((fd = rump_sys_open("/kern/version", 0)) == -1)
		die("open /kern/version");
	printf("\nReading version info from /kern:\n");
	if (rump_sys_read(fd, buf, sizeof(buf)) <= 0)
		die("read version");
	printf("\n%s", buf);
	rump_sys_reboot(0, NULL);

	return 0;
}
示例#12
0
文件: h_mdserv.c 项目: 2asoft/freebsd
static void *
prober(void *arg)
{
	int fd, error;
	char buf[4];
	ssize_t n;

	fd = rump_sys_open(arg, O_RDONLY);
	for (;;) {
		n = rump_sys_read(fd, buf, sizeof(buf));

		switch (n) {
		case 4:
			error = 0;
			goto out;

		case -1:
			if (errno == ENXIO) {
				usleep(1000);
				continue;
			}

			/* FALLTHROUGH */
		default:
			error = EPIPE;
			goto out;
		}
	}
 out:

	error = rump_daemonize_done(error);
	REQUIRE(error, "rump_daemonize_done");

	if (error)
		exit(1);

	return NULL;
}
示例#13
0
void
rumpkern_demo(void)
{
	char buf[256];
	ssize_t nn;
	int fd, rv;

	printk(KERN_INFO "reading rump kernel version from kernfs/version:\n");
	rv = rump_sys_mkdir("/mnt", 0777);
	BUG_ON(rv == -1);

	rv = rump_sys_mount("kernfs", "/mnt", 0, NULL, 0);
	BUG_ON(rv == -1);

	fd = rump_sys_open("/mnt/version", RUMP_O_RDONLY, 0);
	BUG_ON(rv == -1);

	nn = rump_sys_read(fd, buf, sizeof(buf));
	BUG_ON(nn < 1);
	buf[nn] = '\0';

	printk(KERN_INFO "%s", buf);
}
示例#14
0
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);
}