git commit -m "resolved conflicts for merge of d29f641b to stage-aosp-master" (39ac6de4) · Commits · e / os / android_bootable_recovery

fuse_sideload.c

+28 −2

Original line number	Diff line number	Diff line
		@@ -53,6 +53,7 @@
		#include <string.h>
		#include <sys/inotify.h>
		#include <sys/mount.h>
		#include <sys/param.h>
		#include <sys/resource.h>
		#include <sys/stat.h>
		#include <sys/statfs.h>
		@@ -117,15 +118,40 @@ static void fuse_reply(struct fuse_data* fd, __u64 unique, const void *data, siz
		static int handle_init(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) {
		const struct fuse_init_in* req = data;
		struct fuse_init_out out;
		size_t fuse_struct_size;


		/* 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);
		return -1;
		}

		out.minor = MIN(req->minor, FUSE_KERNEL_MINOR_VERSION);
		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 (req->minor <= 22) {
		fuse_struct_size = FUSE_COMPAT_22_INIT_OUT_SIZE;
		}
		#endif

		out.major = FUSE_KERNEL_VERSION;
		out.minor = FUSE_KERNEL_MINOR_VERSION;
		out.max_readahead = req->max_readahead;
		out.flags = 0;
		out.max_background = 32;
		out.congestion_threshold = 32;
		out.max_write = 4096;
		fuse_reply(fd, hdr->unique, &out, sizeof(out));
		fuse_reply(fd, hdr->unique, &out, fuse_struct_size);

		return NO_STATUS;
		}

minzip/Zip.c

+59 −105

Original line number	Diff line number	Diff line
		@@ -828,7 +828,7 @@ static const char targetEntryPath(MzPathHelper helper, ZipEntry *pEntry)
		*/
		bool mzExtractRecursive(const ZipArchive *pArchive,
		const char zipDir, const char targetDir,
		int flags, const struct utimbuf *timestamp,
		const struct utimbuf *timestamp,
		void (callback)(const char fn, void ), void cookie,
		struct selabel_handle *sehnd)
		{
		@@ -932,30 +932,19 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
		break;
		}

		/* With DRY_RUN set, invoke the callback but don't do anything else.
		*/
		if (flags & MZ_EXTRACT_DRY_RUN) {
		if (callback != NULL) callback(targetFile, cookie);
		continue;
		}

		/* Create the file or directory.
		*/
		#define UNZIP_DIRMODE 0755
		#define UNZIP_FILEMODE 0644
		if (pEntry->fileName[pEntry->fileNameLen-1] == '/') {
		if (!(flags & MZ_EXTRACT_FILES_ONLY)) {
		int ret = dirCreateHierarchy(
		targetFile, UNZIP_DIRMODE, timestamp, false, sehnd);
		if (ret != 0) {
		LOGE("Can't create containing directory for \"%s\": %s\n",
		targetFile, strerror(errno));
		ok = false;
		break;
		}
		LOGD("Extracted dir \"%s\"\n", targetFile);
		}
		} else {
		/*
		* Create the file or directory. We ignore directory entries
		* because we recursively create paths to each file entry we encounter
		* in the zip archive anyway.
		*
		* NOTE: A "directory entry" in a zip archive is just a zero length
		* entry that ends in a "/". They're not mandatory and many tools get
		* rid of them. We need to process them only if we want to preserve
		* empty directories from the archive.
		*/
		if (pEntry->fileName[pEntry->fileNameLen-1] != '/') {
		/* This is not a directory. First, make sure that
		* the containing directory exists.
		*/
		@@ -968,52 +957,18 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
		break;
		}

		/* With FILES_ONLY set, we need to ignore metadata entirely,
		* so treat symlinks as regular files.
		*/
		if (!(flags & MZ_EXTRACT_FILES_ONLY) && mzIsZipEntrySymlink(pEntry)) {
		/* The entry is a symbolic link.
		* The relative target of the symlink is in the
		* data section of this entry.
		*/
		if (pEntry->uncompLen == 0) {
		LOGE("Symlink entry \"%s\" has no target\n",
		targetFile);
		ok = false;
		break;
		}
		char *linkTarget = malloc(pEntry->uncompLen + 1);
		if (linkTarget == NULL) {
		ok = false;
		break;
		}
		ok = mzReadZipEntry(pArchive, pEntry, linkTarget,
		pEntry->uncompLen);
		if (!ok) {
		LOGE("Can't read symlink target for \"%s\"\n",
		targetFile);
		free(linkTarget);
		break;
		}
		linkTarget[pEntry->uncompLen] = '\0';

		/* Make the link.
		/*
		* The entry is a regular file or a symlink. Open the target for writing.
		*
		* TODO: This behavior for symlinks seems rather bizarre. For a
		* symlink foo/bar/baz -> foo/tar/taz, we will create a file called
		* "foo/bar/baz" whose contents are the literal "foo/tar/taz". We
		* warn about this for now and preserve older behavior.
		*/
		ret = symlink(linkTarget, targetFile);
		if (ret != 0) {
		LOGE("Can't symlink \"%s\" to \"%s\": %s\n",
		targetFile, linkTarget, strerror(errno));
		free(linkTarget);
		ok = false;
		break;
		if (mzIsZipEntrySymlink(pEntry)) {
		LOGE("Symlink entry \"%.*s\" will be output as a regular file.",
		pEntry->fileNameLen, pEntry->fileName);
		}
		LOGD("Extracted symlink \"%s\" -> \"%s\"\n",
		targetFile, linkTarget);
		free(linkTarget);
		} else {
		/* The entry is a regular file.
		* Open the target for writing.
		*/

		char *secontext = NULL;

		@@ -1022,8 +977,8 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
		setfscreatecon(secontext);
		}

		int fd = open(targetFile, O_CREAT\|O_WRONLY\|O_TRUNC\|O_SYNC
		, UNZIP_FILEMODE);
		int fd = open(targetFile, O_CREAT\|O_WRONLY\|O_TRUNC\|O_SYNC,
		UNZIP_FILEMODE);

		if (secontext) {
		freecon(secontext);
		@@ -1059,7 +1014,6 @@ bool mzExtractRecursive(const ZipArchive *pArchive,
		LOGV("Extracted file \"%s\"\n", targetFile);
		++extractCount;
		}
		}

		if (callback != NULL) callback(targetFile, cookie);
		}

minzip/Zip.h

+5 −8

Original line number	Diff line number	Diff line
		@@ -143,9 +143,12 @@ bool mzExtractZipEntryToBuffer(const ZipArchive *pArchive,
		const ZipEntry pEntry, unsigned char buffer);

		/*
		* Inflate all entries under zipDir to the directory specified by
		* Inflate all files under zipDir to the directory specified by
		* targetDir, which must exist and be a writable directory.
		*
		* Directory entries and symlinks are not extracted.
		*
		*
		* The immediate children of zipDir will become the immediate
		* children of targetDir; e.g., if the archive contains the entries
		*
		@@ -160,21 +163,15 @@ bool mzExtractZipEntryToBuffer(const ZipArchive *pArchive,
		* /tmp/two
		* /tmp/d/three
		*
		* flags is zero or more of the following:
		*
		* MZ_EXTRACT_FILES_ONLY - only unpack files, not directories or symlinks
		* MZ_EXTRACT_DRY_RUN - don't do anything, but do invoke the callback
		*
		* If timestamp is non-NULL, file timestamps will be set accordingly.
		*
		* If callback is non-NULL, it will be invoked with each unpacked file.
		*
		* Returns true on success, false on failure.
		*/
		enum { MZ_EXTRACT_FILES_ONLY = 1, MZ_EXTRACT_DRY_RUN = 2 };
		bool mzExtractRecursive(const ZipArchive *pArchive,
		const char zipDir, const char targetDir,
		int flags, const struct utimbuf *timestamp,
		const struct utimbuf *timestamp,
		void (callback)(const char fn, void), void cookie,
		struct selabel_handle *sehnd);

updater/blockimg.c

+1551 −437

File changed.

Preview size limit exceeded, changes collapsed.

updater/install.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -496,7 +496,7 @@ Value* PackageExtractDirFn(const char* name, State* state,
		struct utimbuf timestamp = { 1217592000, 1217592000 }; // 8/1/2008 default

		bool success = mzExtractRecursive(za, zip_path, dest_path,
		MZ_EXTRACT_FILES_ONLY, &timestamp,
		&timestamp,
		NULL, NULL, sehandle);
		free(zip_path);
		free(dest_path);