Clean up fuse_sideload and add a testcase. (91a7aa45) · Commits · e / os / android_bootable_recovery

fuse_sdcard_provider.cpp

+43 −45

Original line number	Diff line number	Diff line
		@@ -14,14 +14,18 @@
		* limitations under the License.
		*/

		#include <stdlib.h>
		#include "fuse_sdcard_provider.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <errno.h>
		#include <sys/mount.h>
		#include <sys/stat.h>
		#include <unistd.h>
		#include <fcntl.h>

		#include <functional>

		#include <android-base/file.h>

		@@ -34,16 +38,15 @@ struct file_data {
		uint32_t block_size;
		};

		static int read_block_file(void* cookie, uint32_t block, uint8_t* buffer, uint32_t fetch_size) {
		file_data* fd = reinterpret_cast<file_data*>(cookie);

		off64_t offset = ((off64_t) block) * fd->block_size;
		if (TEMP_FAILURE_RETRY(lseek64(fd->fd, offset, SEEK_SET)) == -1) {
		static int read_block_file(const file_data& fd, uint32_t block, uint8_t* buffer,
		uint32_t fetch_size) {
		off64_t offset = static_cast<off64_t>(block) * fd.block_size;
		if (TEMP_FAILURE_RETRY(lseek64(fd.fd, offset, SEEK_SET)) == -1) {
		fprintf(stderr, "seek on sdcard failed: %s\n", strerror(errno));
		return -EIO;
		}

		if (!android::base::ReadFully(fd->fd, buffer, fetch_size)) {
		if (!android::base::ReadFully(fd.fd, buffer, fetch_size)) {
		fprintf(stderr, "read on sdcard failed: %s\n", strerror(errno));
		return -EIO;
		}
		@@ -51,11 +54,6 @@ static int read_block_file(void* cookie, uint32_t block, uint8_t* buffer, uint32
		return 0;
		}

		static void close_file(void* cookie) {
		file_data* fd = reinterpret_cast<file_data*>(cookie);
		close(fd->fd);
		}

		bool start_sdcard_fuse(const char* path) {
		struct stat sb;
		if (stat(path, &sb) == -1) {
		@@ -73,13 +71,13 @@ bool start_sdcard_fuse(const char* path) {
		fd.block_size = 65536;

		provider_vtab vtab;
		vtab.read_block = read_block_file;
		vtab.close = close_file;
		vtab.read_block = std::bind(&read_block_file, fd, std::placeholders::_1, std::placeholders::_2,
		std::placeholders::_3);
		vtab.close = [&fd]() { close(fd.fd); };

		// The installation process expects to find the sdcard unmounted.
		// Unmount it with MNT_DETACH so that our open file continues to
		// work but new references see it as unmounted.
		// The installation process expects to find the sdcard unmounted. Unmount it with MNT_DETACH so
		// that our open file continues to work but new references see it as unmounted.
		umount2("/sdcard", MNT_DETACH);

		return run_fuse_sideload(&vtab, &fd, fd.file_size, fd.block_size) == 0;
		return run_fuse_sideload(vtab, fd.file_size, fd.block_size) == 0;
		}

fuse_sideload.cpp

+254 −291

Original line number	Diff line number	Diff line
		@@ -41,44 +41,42 @@
		// two files is implemented. In particular, you can't opendir() or
		// readdir() on the "/sideload" directory; ls on it won't work.

		#include <ctype.h>
		#include <dirent.h>
		#include "fuse_sideload.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <limits.h>
		#include <limits.h> // PATH_MAX
		#include <linux/fuse.h>
		#include <pthread.h>
		#include <stdint.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <sys/inotify.h>
		#include <sys/mount.h>
		#include <sys/param.h>
		#include <sys/resource.h>
		#include <sys/param.h> // MIN
		#include <sys/stat.h>
		#include <sys/statfs.h>
		#include <sys/time.h>
		#include <sys/uio.h>
		#include <unistd.h>

		#include <array>
		#include <string>
		#include <vector>

		#include <android-base/stringprintf.h>
		#include <android-base/unique_fd.h>
		#include <openssl/sha.h>

		#include "fuse_sideload.h"
		static constexpr uint64_t PACKAGE_FILE_ID = FUSE_ROOT_ID + 1;
		static constexpr uint64_t EXIT_FLAG_ID = FUSE_ROOT_ID + 2;

		#define PACKAGE_FILE_ID (FUSE_ROOT_ID+1)
		#define EXIT_FLAG_ID (FUSE_ROOT_ID+2)
		static constexpr int NO_STATUS = 1;
		static constexpr int NO_STATUS_EXIT = 2;

		#define NO_STATUS 1
		#define NO_STATUS_EXIT 2
		using SHA256Digest = std::array<uint8_t, SHA256_DIGEST_LENGTH>;

		struct fuse_data {
		int ffd; // file descriptor for the fuse socket
		android::base::unique_fd ffd; // file descriptor for the fuse socket

		struct provider_vtab* vtab;
		void* cookie;
		provider_vtab vtab;

		uint64_t file_size; // bytes

		@@ -91,59 +89,50 @@ struct fuse_data {
		uint32_t curr_block; // cache the block most recently read from the host
		uint8_t* block_data;

		uint8_t* extra_block; // another block of storage for reads that
		// span two blocks
		uint8_t* extra_block; // another block of storage for reads that span two blocks

		uint8_t* hashes; // SHA-256 hash of each block (all zeros
		// if block hasn't been read yet)
		std::vector<SHA256Digest>
		hashes; // SHA-256 hash of each block (all zeros if block hasn't been read yet)
		};

		static void fuse_reply(struct fuse_data* fd, __u64 unique, const void *data, size_t len)
		{
		struct fuse_out_header hdr;
		struct iovec vec[2];
		int res;

		static void fuse_reply(const fuse_data* fd, uint64_t unique, const void* data, size_t len) {
		fuse_out_header hdr;
		hdr.len = len + sizeof(hdr);
		hdr.error = 0;
		hdr.unique = unique;

		struct iovec vec[2];
		vec[0].iov_base = &hdr;
		vec[0].iov_len = sizeof(hdr);
		vec[1].iov_base = /* const_cast /(void)(data);
		vec[1].iov_base = const_cast<void*>(data);
		vec[1].iov_len = len;

		res = writev(fd->ffd, vec, 2);
		if (res < 0) {
		int res = writev(fd->ffd, vec, 2);
		if (res == -1) {
		printf("* REPLY FAILED * %s\n", strerror(errno));
		}
		}

		static int handle_init(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) {
		const struct fuse_init_in* req = reinterpret_cast<const struct fuse_init_in*>(data);
		struct fuse_init_out out;
		size_t fuse_struct_size;

		static int handle_init(void* data, fuse_data* fd, const fuse_in_header* hdr) {
		const fuse_init_in* req = static_cast<const fuse_init_in*>(data);

		/* Kernel 2.6.16 is the first stable kernel with struct fuse_init_out
		* defined (fuse version 7.6). The structure is the same from 7.6 through
		* 7.22. Beginning with 7.23, the structure increased in size and added
		* new parameters.
		*/
		// Kernel 2.6.16 is the first stable kernel with struct fuse_init_out defined (fuse version 7.6).
		// The structure is the same from 7.6 through 7.22. Beginning with 7.23, the structure increased
		// in size and added new parameters.
		if (req->major != FUSE_KERNEL_VERSION \|\| req->minor < 6) {
		printf("Fuse kernel version mismatch: Kernel version %d.%d, Expected at least %d.6",
		req->major, req->minor, FUSE_KERNEL_VERSION);
		printf("Fuse kernel version mismatch: Kernel version %d.%d, Expected at least %d.6", req->major,
		req->minor, FUSE_KERNEL_VERSION);
		return -1;
		}

		fuse_init_out out;
		out.minor = MIN(req->minor, FUSE_KERNEL_MINOR_VERSION);
		fuse_struct_size = sizeof(out);
		size_t fuse_struct_size = sizeof(out);
		#if defined(FUSE_COMPAT_22_INIT_OUT_SIZE)
		/* FUSE_KERNEL_VERSION >= 23. */

		/* If the kernel only works on minor revs older than or equal to 22,
		* then use the older structure size since this code only uses the 7.22
		* version of the structure. */
		// If the kernel only works on minor revs older than or equal to 22, then use the older structure
		// size since this code only uses the 7.22 version of the structure.
		if (req->minor <= 22) {
		fuse_struct_size = FUSE_COMPAT_22_INIT_OUT_SIZE;
		}
		@@ -160,9 +149,9 @@ static int handle_init(void* data, struct fuse_data* fd, const struct fuse_in_he
		return NO_STATUS;
		}

		static void fill_attr(struct fuse_attr* attr, struct fuse_data* fd,
		uint64_t nodeid, uint64_t size, uint32_t mode) {
		memset(attr, 0, sizeof(*attr));
		static void fill_attr(fuse_attr* attr, const fuse_data* fd, uint64_t nodeid, uint64_t size,
		uint32_t mode) {
		*attr = {};
		attr->nlink = 1;
		attr->uid = fd->uid;
		attr->gid = fd->gid;
		@@ -174,9 +163,8 @@ static void fill_attr(struct fuse_attr* attr, struct fuse_data* fd,
		attr->mode = mode;
		}

		static int handle_getattr(void* /* data /, struct fuse_data fd, const struct fuse_in_header* hdr) {
		struct fuse_attr_out out;
		memset(&out, 0, sizeof(out));
		static int handle_getattr(void* /* data /, const fuse_data fd, const fuse_in_header* hdr) {
		fuse_attr_out out = {};
		out.attr_valid = 10;

		if (hdr->nodeid == FUSE_ROOT_ID) {
		@@ -193,20 +181,19 @@ static int handle_getattr(void* /* data /, struct fuse_data fd, const struct f
		return (hdr->nodeid == EXIT_FLAG_ID) ? NO_STATUS_EXIT : NO_STATUS;
		}

		static int handle_lookup(void* data, struct fuse_data* fd,
		const struct fuse_in_header* hdr) {
		struct fuse_entry_out out;
		memset(&out, 0, sizeof(out));
		static int handle_lookup(void* data, const fuse_data* fd, const fuse_in_header* hdr) {
		if (data == nullptr) return -ENOENT;

		fuse_entry_out out = {};
		out.entry_valid = 10;
		out.attr_valid = 10;

		if (strncmp(FUSE_SIDELOAD_HOST_FILENAME, reinterpret_cast<const char*>(data),
		sizeof(FUSE_SIDELOAD_HOST_FILENAME)) == 0) {
		std::string filename(static_cast<const char*>(data));
		if (filename == FUSE_SIDELOAD_HOST_FILENAME) {
		out.nodeid = PACKAGE_FILE_ID;
		out.generation = PACKAGE_FILE_ID;
		fill_attr(&(out.attr), fd, PACKAGE_FILE_ID, fd->file_size, S_IFREG \| 0444);
		} else if (strncmp(FUSE_SIDELOAD_HOST_EXIT_FLAG, reinterpret_cast<const char*>(data),
		sizeof(FUSE_SIDELOAD_HOST_EXIT_FLAG)) == 0) {
		} else if (filename == FUSE_SIDELOAD_HOST_EXIT_FLAG) {
		out.nodeid = EXIT_FLAG_ID;
		out.generation = EXIT_FLAG_ID;
		fill_attr(&(out.attr), fd, EXIT_FLAG_ID, 0, S_IFREG \| 0);
		@@ -218,30 +205,27 @@ static int handle_lookup(void* data, struct fuse_data* fd,
		return (out.nodeid == EXIT_FLAG_ID) ? NO_STATUS_EXIT : NO_STATUS;
		}

		static int handle_open(void* /* data /, struct fuse_data fd, const struct fuse_in_header* hdr) {
		static int handle_open(void* /* data /, const fuse_data fd, const fuse_in_header* hdr) {
		if (hdr->nodeid == EXIT_FLAG_ID) return -EPERM;
		if (hdr->nodeid != PACKAGE_FILE_ID) return -ENOENT;

		struct fuse_open_out out;
		memset(&out, 0, sizeof(out));
		fuse_open_out out = {};
		out.fh = 10; // an arbitrary number; we always use the same handle
		fuse_reply(fd, hdr->unique, &out, sizeof(out));
		return NO_STATUS;
		}

		static int handle_flush(void* /* data /, struct fuse_data /* fd */,
		const struct fuse_in_header* /* hdr */) {
		static int handle_flush(void* /* data /, fuse_data /* fd /, const fuse_in_header /* hdr */) {
		return 0;
		}

		static int handle_release(void* /* data /, struct fuse_data /* fd */,
		const struct fuse_in_header* /* hdr */) {
		static int handle_release(void* /* data /, fuse_data /* fd /, const fuse_in_header /* hdr */) {
		return 0;
		}

		// Fetch a block from the host into fd->curr_block and fd->block_data.
		// Returns 0 on successful fetch, negative otherwise.
		static int fetch_block(struct fuse_data* fd, uint32_t block) {
		static int fetch_block(fuse_data* fd, uint32_t block) {
		if (block == fd->curr_block) {
		return 0;
		}
		@@ -254,92 +238,82 @@ static int fetch_block(struct fuse_data* fd, uint32_t block) {

		size_t fetch_size = fd->block_size;
		if (block * fd->block_size + fetch_size > fd->file_size) {
		// If we're reading the last (partial) block of the file,
		// expect a shorter response from the host, and pad the rest
		// of the block with zeroes.
		// If we're reading the last (partial) block of the file, expect a shorter response from the
		// host, and pad the rest of the block with zeroes.
		fetch_size = fd->file_size - (block * fd->block_size);
		memset(fd->block_data + fetch_size, 0, fd->block_size - fetch_size);
		}

		int result = fd->vtab->read_block(fd->cookie, block, fd->block_data, fetch_size);
		int result = fd->vtab.read_block(block, fd->block_data, fetch_size);
		if (result < 0) return result;

		fd->curr_block = block;

		// Verify the hash of the block we just got from the host.
		//
		// - If the hash of the just-received data matches the stored hash
		// for the block, accept it.
		// - If the stored hash is all zeroes, store the new hash and
		// accept the block (this is the first time we've read this
		// block).
		// - If the hash of the just-received data matches the stored hash for the block, accept it.
		// - If the stored hash is all zeroes, store the new hash and accept the block (this is the first
		// time we've read this block).
		// - Otherwise, return -EINVAL for the read.

		uint8_t hash[SHA256_DIGEST_LENGTH];
		SHA256(fd->block_data, fd->block_size, hash);
		uint8_t* blockhash = fd->hashes + block * SHA256_DIGEST_LENGTH;
		if (memcmp(hash, blockhash, SHA256_DIGEST_LENGTH) == 0) {
		SHA256Digest hash;
		SHA256(fd->block_data, fd->block_size, hash.data());

		const SHA256Digest& blockhash = fd->hashes[block];
		if (hash == blockhash) {
		return 0;
		}

		int i;
		for (i = 0; i < SHA256_DIGEST_LENGTH; ++i) {
		if (blockhash[i] != 0) {
		for (uint8_t i : blockhash) {
		if (i != 0) {
		fd->curr_block = -1;
		return -EIO;
		}
		}

		memcpy(blockhash, hash, SHA256_DIGEST_LENGTH);
		fd->hashes[block] = hash;
		return 0;
		}

		static int handle_read(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) {
		const struct fuse_read_in* req = reinterpret_cast<const struct fuse_read_in*>(data);
		struct fuse_out_header outhdr;
		struct iovec vec[3];
		int vec_used;
		int result;

		static int handle_read(void* data, fuse_data* fd, const fuse_in_header* hdr) {
		if (hdr->nodeid != PACKAGE_FILE_ID) return -ENOENT;

		const fuse_read_in* req = static_cast<const fuse_read_in*>(data);
		uint64_t offset = req->offset;
		uint32_t size = req->size;

		// The docs on the fuse kernel interface are vague about what to
		// do when a read request extends past the end of the file. We
		// can return a short read -- the return structure does include a
		// length field -- but in testing that caused the program using
		// the file to segfault. (I speculate that this is due to the
		// reading program accessing it via mmap; maybe mmap dislikes when
		// you return something short of a whole page?) To fix this we
		// zero-pad reads that extend past the end of the file so we're
		// always returning exactly as many bytes as were requested.
		// The docs on the fuse kernel interface are vague about what to do when a read request extends
		// past the end of the file. We can return a short read -- the return structure does include a
		// length field -- but in testing that caused the program using the file to segfault. (I
		// speculate that this is due to the reading program accessing it via mmap; maybe mmap dislikes
		// when you return something short of a whole page?) To fix this we zero-pad reads that extend
		// past the end of the file so we're always returning exactly as many bytes as were requested.
		// (Users of the mapped file have to know its real length anyway.)

		fuse_out_header outhdr;
		outhdr.len = sizeof(outhdr) + size;
		outhdr.error = 0;
		outhdr.unique = hdr->unique;

		struct iovec vec[3];
		vec[0].iov_base = &outhdr;
		vec[0].iov_len = sizeof(outhdr);

		uint32_t block = offset / fd->block_size;
		result = fetch_block(fd, block);
		int result = fetch_block(fd, block);
		if (result != 0) return result;

		// Two cases:
		//
		// - the read request is entirely within this block. In this
		// case we can reply immediately.
		// - the read request is entirely within this block. In this case we can reply immediately.
		//
		// - the read request goes over into the next block. Note that
		// since we mount the filesystem with max_read=block_size, a
		// read can never span more than two blocks. In this case we
		// copy the block to extra_block and issue a fetch for the
		// following block.
		// - the read request goes over into the next block. Note that since we mount the filesystem
		// with max_read=block_size, a read can never span more than two blocks. In this case we copy
		// the block to extra_block and issue a fetch for the following block.

		uint32_t block_offset = offset - (block * fd->block_size);

		int vec_used;
		if (size + block_offset <= fd->block_size) {
		// First case: the read fits entirely in the first block.

		@@ -349,8 +323,7 @@ static int handle_read(void* data, struct fuse_data* fd, const struct fuse_in_he
		} else {
		// Second case: the read spills over into the next block.

		memcpy(fd->extra_block, fd->block_data + block_offset,
		fd->block_size - block_offset);
		memcpy(fd->extra_block, fd->block_data + block_offset, fd->block_size - block_offset);
		vec[1].iov_base = fd->extra_block;
		vec[1].iov_len = fd->block_size - block_offset;

		@@ -361,17 +334,17 @@ static int handle_read(void* data, struct fuse_data* fd, const struct fuse_in_he
		vec_used = 3;
		}

		if (writev(fd->ffd, vec, vec_used) < 0) {
		if (writev(fd->ffd, vec, vec_used) == -1) {
		printf("* READ REPLY FAILED: %s *\n", strerror(errno));
		}
		return NO_STATUS;
		}

		int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_size,
		uint32_t block_size) {
		int run_fuse_sideload(const provider_vtab& vtab, uint64_t file_size, uint32_t block_size,
		const char* mount_point) {
		// If something's already mounted on our mountpoint, try to remove it. (Mostly in case of a
		// previous abnormal exit.)
		umount2(FUSE_SIDELOAD_HOST_MOUNTPOINT, MNT_FORCE);
		umount2(mount_point, MNT_FORCE);

		// fs/fuse/inode.c in kernel code uses the greater of 4096 and the passed-in max_read.
		if (block_size < 4096) {
		@@ -383,9 +356,8 @@ int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_si
		return -1;
		}

		struct fuse_data fd = {};
		fuse_data fd = {};
		fd.vtab = vtab;
		fd.cookie = cookie;
		fd.file_size = file_size;
		fd.block_size = block_size;
		fd.file_blocks = (file_size == 0) ? 0 : (((file_size - 1) / block_size) + 1);
		@@ -397,33 +369,27 @@ int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_si
		goto done;
		}

		fd.hashes = (uint8_t*)calloc(fd.file_blocks, SHA256_DIGEST_LENGTH);
		if (fd.hashes == NULL) {
		fprintf(stderr, "failed to allocate %d bites for hashes\n",
		fd.file_blocks * SHA256_DIGEST_LENGTH);
		result = -1;
		goto done;
		}

		// All hashes will be zero-initialized.
		fd.hashes.resize(fd.file_blocks);
		fd.uid = getuid();
		fd.gid = getgid();

		fd.curr_block = -1;
		fd.block_data = (uint8_t*)malloc(block_size);
		if (fd.block_data == NULL) {
		fd.block_data = static_cast<uint8_t*>(malloc(block_size));
		if (fd.block_data == nullptr) {
		fprintf(stderr, "failed to allocate %d bites for block_data\n", block_size);
		result = -1;
		goto done;
		}
		fd.extra_block = (uint8_t*)malloc(block_size);
		if (fd.extra_block == NULL) {
		fd.extra_block = static_cast<uint8_t*>(malloc(block_size));
		if (fd.extra_block == nullptr) {
		fprintf(stderr, "failed to allocate %d bites for extra_block\n", block_size);
		result = -1;
		goto done;
		}

		fd.ffd = open("/dev/fuse", O_RDWR);
		if (fd.ffd < 0) {
		fd.ffd.reset(open("/dev/fuse", O_RDWR));
		if (!fd.ffd) {
		perror("open /dev/fuse");
		result = -1;
		goto done;
		@@ -431,18 +397,18 @@ int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_si

		{
		std::string opts = android::base::StringPrintf(
		"fd=%d,user_id=%d,group_id=%d,max_read=%u,allow_other,rootmode=040000", fd.ffd, fd.uid,
		fd.gid, block_size);
		"fd=%d,user_id=%d,group_id=%d,max_read=%u,allow_other,rootmode=040000", fd.ffd.get(),
		fd.uid, fd.gid, block_size);

		result = mount("/dev/fuse", FUSE_SIDELOAD_HOST_MOUNTPOINT, "fuse",
		MS_NOSUID \| MS_NODEV \| MS_RDONLY \| MS_NOEXEC, opts.c_str());
		if (result < 0) {
		result = mount("/dev/fuse", mount_point, "fuse", MS_NOSUID \| MS_NODEV \| MS_RDONLY \| MS_NOEXEC,
		opts.c_str());
		if (result == -1) {
		perror("mount");
		goto done;
		}
		}

		uint8_t request_buffer[sizeof(struct fuse_in_header) + PATH_MAX * 8];
		uint8_t request_buffer[sizeof(fuse_in_header) + PATH_MAX * 8];
		for (;;) {
		ssize_t len = TEMP_FAILURE_RETRY(read(fd.ffd, request_buffer, sizeof(request_buffer)));
		if (len == -1) {
		@@ -454,13 +420,13 @@ int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_si
		continue;
		}

		if (static_cast<size_t>(len) < sizeof(struct fuse_in_header)) {
		if (static_cast<size_t>(len) < sizeof(fuse_in_header)) {
		fprintf(stderr, "request too short: len=%zd\n", len);
		continue;
		}

		struct fuse_in_header* hdr = reinterpret_cast<struct fuse_in_header*>(request_buffer);
		void* data = request_buffer + sizeof(struct fuse_in_header);
		fuse_in_header* hdr = reinterpret_cast<fuse_in_header*>(request_buffer);
		void* data = request_buffer + sizeof(fuse_in_header);

		result = -ENOSYS;

		@@ -504,7 +470,7 @@ int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_si
		}

		if (result != NO_STATUS) {
		struct fuse_out_header outhdr;
		fuse_out_header outhdr;
		outhdr.len = sizeof(outhdr);
		outhdr.error = result;
		outhdr.unique = hdr->unique;
		@@ -513,15 +479,12 @@ int run_fuse_sideload(struct provider_vtab* vtab, void* cookie, uint64_t file_si
		}

		done:
		fd.vtab->close(fd.cookie);
		fd.vtab.close();

		result = umount2(FUSE_SIDELOAD_HOST_MOUNTPOINT, MNT_DETACH);
		if (result < 0) {
		printf("fuse_sideload umount failed: %s\n", strerror(errno));
		if (umount2(mount_point, MNT_DETACH) == -1) {
		fprintf(stderr, "fuse_sideload umount failed: %s\n", strerror(errno));
		}

		if (fd.ffd) close(fd.ffd);
		free(fd.hashes);
		free(fd.block_data);
		free(fd.extra_block);

fuse_sideload.h

+14 −12

Original line number	Diff line number	Diff line
		@@ -17,22 +17,24 @@
		#ifndef __FUSE_SIDELOAD_H
		#define __FUSE_SIDELOAD_H

		// define the filenames created by the sideload FUSE filesystem
		#define FUSE_SIDELOAD_HOST_MOUNTPOINT "/sideload"
		#define FUSE_SIDELOAD_HOST_FILENAME "package.zip"
		#define FUSE_SIDELOAD_HOST_PATHNAME (FUSE_SIDELOAD_HOST_MOUNTPOINT "/" FUSE_SIDELOAD_HOST_FILENAME)
		#define FUSE_SIDELOAD_HOST_EXIT_FLAG "exit"
		#define FUSE_SIDELOAD_HOST_EXIT_PATHNAME (FUSE_SIDELOAD_HOST_MOUNTPOINT "/" FUSE_SIDELOAD_HOST_EXIT_FLAG)
		#include <functional>

		// Define the filenames created by the sideload FUSE filesystem.
		static constexpr const char* FUSE_SIDELOAD_HOST_MOUNTPOINT = "/sideload";
		static constexpr const char* FUSE_SIDELOAD_HOST_FILENAME = "package.zip";
		static constexpr const char* FUSE_SIDELOAD_HOST_PATHNAME = "/sideload/package.zip";
		static constexpr const char* FUSE_SIDELOAD_HOST_EXIT_FLAG = "exit";
		static constexpr const char* FUSE_SIDELOAD_HOST_EXIT_PATHNAME = "/sideload/exit";

		struct provider_vtab {
		// read a block
		int (read_block)(void cookie, uint32_t block, uint8_t* buffer, uint32_t fetch_size);
		std::function<int(uint32_t block, uint8_t* buffer, uint32_t fetch_size)> read_block;

		// close down
		void (close)(void cookie);
		std::function<void(void)> close;
		};

		int run_fuse_sideload(struct provider_vtab* vtab, void* cookie,
		uint64_t file_size, uint32_t block_size);
		int run_fuse_sideload(const provider_vtab& vtab, uint64_t file_size, uint32_t block_size,
		const char* mount_point = FUSE_SIDELOAD_HOST_MOUNTPOINT);

		#endif

minadbd/fuse_adb_provider.cpp

+25 −28

Original line number	Diff line number	Diff line
		@@ -14,25 +14,26 @@
		* limitations under the License.
		*/

		#include <stdlib.h>
		#include "fuse_adb_provider.h"

		#include <errno.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <errno.h>

		#include <functional>

		#include "adb.h"
		#include "adb_io.h"
		#include "fuse_adb_provider.h"
		#include "fuse_sideload.h"

		int read_block_adb(void* data, uint32_t block, uint8_t* buffer, uint32_t fetch_size) {
		adb_data* ad = reinterpret_cast<adb_data*>(data);

		if (!WriteFdFmt(ad->sfd, "%08u", block)) {
		int read_block_adb(const adb_data& ad, uint32_t block, uint8_t* buffer, uint32_t fetch_size) {
		if (!WriteFdFmt(ad.sfd, "%08u", block)) {
		fprintf(stderr, "failed to write to adb host: %s\n", strerror(errno));
		return -EIO;
		}

		if (!ReadFdExactly(ad->sfd, buffer, fetch_size)) {
		if (!ReadFdExactly(ad.sfd, buffer, fetch_size)) {
		fprintf(stderr, "failed to read from adb host: %s\n", strerror(errno));
		return -EIO;
		}
		@@ -40,11 +41,6 @@ int read_block_adb(void* data, uint32_t block, uint8_t* buffer, uint32_t fetch_s
		return 0;
		}

		static void close_adb(void* data) {
		adb_data* ad = reinterpret_cast<adb_data*>(data);
		WriteFdExactly(ad->sfd, "DONEDONE");
		}

		int run_adb_fuse(int sfd, uint64_t file_size, uint32_t block_size) {
		adb_data ad;
		ad.sfd = sfd;
		@@ -52,8 +48,9 @@ int run_adb_fuse(int sfd, uint64_t file_size, uint32_t block_size) {
		ad.block_size = block_size;

		provider_vtab vtab;
		vtab.read_block = read_block_adb;
		vtab.close = close_adb;
		vtab.read_block = std::bind(read_block_adb, ad, std::placeholders::_1, std::placeholders::_2,
		std::placeholders::_3);
		vtab.close = [&ad]() { WriteFdExactly(ad.sfd, "DONEDONE"); };

		return run_fuse_sideload(&vtab, &ad, file_size, block_size);
		return run_fuse_sideload(vtab, file_size, block_size);
		}

minadbd/fuse_adb_provider.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -26,7 +26,7 @@ struct adb_data {
		uint32_t block_size;
		};

		int read_block_adb(void* cookie, uint32_t block, uint8_t* buffer, uint32_t fetch_size);
		int read_block_adb(const adb_data& ad, uint32_t block, uint8_t* buffer, uint32_t fetch_size);
		int run_adb_fuse(int sfd, uint64_t file_size, uint32_t block_size);

		#endif