Snap for 4428213 from 9a3af552a011f92389abb0d99949c477f444cffb to pi-release (3f0d4924) · Commits · e / os / android_system_core

bootstat/bootstat.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -227,6 +227,7 @@ const std::map<std::string, int32_t> kBootReasonMap = {
		{"shutdown,thermal,battery", 87},
		{"reboot,its_just_so_hard", 88}, // produced by boot_reason_test
		{"reboot,Its Just So Hard", 89}, // produced by boot_reason_test
		{"usb", 90},
		};

		// Converts a string value representing the reason the system booted to an

libziparchive/include/ziparchive/zip_archive.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -265,6 +265,9 @@ class Reader {
		* Returns 0 on success and negative values on failure, for example if \|reader\|
		* cannot supply the right amount of data, or if the number of bytes written to
		* data does not match \|uncompressed_length\|.
		*
		* If \|crc_out\| is not nullptr, it is set to the crc32 checksum of the
		* uncompressed data.
		*/
		int32_t Inflate(const Reader& reader, const uint32_t compressed_length,
		const uint32_t uncompressed_length, Writer* writer, uint64_t* crc_out);

libziparchive/zip_archive.cc

+6 −4

Original line number	Diff line number	Diff line
		@@ -924,6 +924,7 @@ int32_t Inflate(const Reader& reader, const uint32_t compressed_length,

		std::unique_ptr<z_stream, decltype(zstream_deleter)> zstream_guard(&zstream, zstream_deleter);

		const bool compute_crc = (crc_out != nullptr);
		uint64_t crc = 0;
		uint32_t remaining_bytes = compressed_length;
		do {
		@@ -955,9 +956,8 @@ int32_t Inflate(const Reader& reader, const uint32_t compressed_length,
		if (zstream.avail_out == 0 \|\| (zerr == Z_STREAM_END && zstream.avail_out != kBufSize)) {
		const size_t write_size = zstream.next_out - &write_buf[0];
		if (!writer->Append(&write_buf[0], write_size)) {
		// The file might have declared a bogus length.
		return kInconsistentInformation;
		} else {
		return kIoError;
		} else if (compute_crc) {
		crc = crc32(crc, &write_buf[0], write_size);
		}

		@@ -974,7 +974,9 @@ int32_t Inflate(const Reader& reader, const uint32_t compressed_length,
		// it ourselves above because there are no additional gains to be made by
		// having zlib calculate it for us, since they do it by calling crc32 in
		// the same manner that we have above.
		if (compute_crc) {
		*crc_out = crc;
		}

		if (zstream.total_out != uncompressed_length \|\| remaining_bytes != 0) {
		ALOGW("Zip: size mismatch on inflated file (%lu vs %" PRIu32 ")", zstream.total_out,

libziparchive/zip_archive_test.cc

+87 −0

Original line number	Diff line number	Diff line
		@@ -766,6 +766,93 @@ TEST(ziparchive, BrokenLfhSignature) {
		ASSERT_EQ(-1, OpenArchiveFd(tmp_file.fd, "LeadingNonZipBytes", &handle));
		}

		class VectorReader : public zip_archive::Reader {
		public:
		VectorReader(const std::vector<uint8_t>& input) : Reader(), input_(input) {}

		bool ReadAtOffset(uint8_t* buf, size_t len, uint32_t offset) const {
		if ((offset + len) < input_.size()) {
		return false;
		}

		memcpy(buf, &input_[offset], len);
		return true;
		}

		private:
		const std::vector<uint8_t>& input_;
		};

		class VectorWriter : public zip_archive::Writer {
		public:
		VectorWriter() : Writer() {}

		bool Append(uint8_t* buf, size_t size) {
		output_.insert(output_.end(), buf, buf + size);
		return true;
		}

		std::vector<uint8_t>& GetOutput() { return output_; }

		private:
		std::vector<uint8_t> output_;
		};

		class BadReader : public zip_archive::Reader {
		public:
		BadReader() : Reader() {}

		bool ReadAtOffset(uint8_t*, size_t, uint32_t) const { return false; }
		};

		class BadWriter : public zip_archive::Writer {
		public:
		BadWriter() : Writer() {}

		bool Append(uint8_t*, size_t) { return false; }
		};

		TEST(ziparchive, Inflate) {
		const uint32_t compressed_length = kATxtContentsCompressed.size();
		const uint32_t uncompressed_length = kATxtContents.size();

		const VectorReader reader(kATxtContentsCompressed);
		{
		VectorWriter writer;
		uint64_t crc_out = 0;

		int32_t ret =
		zip_archive::Inflate(reader, compressed_length, uncompressed_length, &writer, &crc_out);
		ASSERT_EQ(0, ret);
		ASSERT_EQ(kATxtContents, writer.GetOutput());
		ASSERT_EQ(0x950821C5u, crc_out);
		}

		{
		VectorWriter writer;
		int32_t ret =
		zip_archive::Inflate(reader, compressed_length, uncompressed_length, &writer, nullptr);
		ASSERT_EQ(0, ret);
		ASSERT_EQ(kATxtContents, writer.GetOutput());
		}

		{
		BadWriter writer;
		int32_t ret =
		zip_archive::Inflate(reader, compressed_length, uncompressed_length, &writer, nullptr);
		ASSERT_EQ(kIoError, ret);
		}

		{
		BadReader reader;
		VectorWriter writer;
		int32_t ret =
		zip_archive::Inflate(reader, compressed_length, uncompressed_length, &writer, nullptr);
		ASSERT_EQ(kIoError, ret);
		ASSERT_EQ(0u, writer.GetOutput().size());
		}
		}

		int main(int argc, char** argv) {
		::testing::InitGoogleTest(&argc, argv);

logcat/logcat.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -457,7 +457,7 @@ static void show_help(android_logcat_context_internal* context) {
		" -d Dump the log and then exit (don't block)\n"
		" -e <expr>, --regex=<expr>\n"
		" Only print lines where the log message matches <expr>\n"
		" where <expr> is a regular expression\n"
		" where <expr> is a Perl-compatible regular expression\n"
		// Leave --head undocumented as alias for -m
		" -m <count>, --max-count=<count>\n"
		" Quit after printing <count> lines. This is meant to be\n"