| #! /usr/bin/env python | |
| # Copyright (C) 2012 The Android Open Source Project | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| from __future__ import print_function | |
| import csv | |
| import getopt | |
| import hashlib | |
| import posixpath | |
| import signal | |
| import struct | |
| import sys | |
| def usage(argv0): | |
| print(""" | |
| Usage: %s [-v] [-s] [-c <filename>] sparse_image_file ... | |
| -v verbose output | |
| -s show sha1sum of data blocks | |
| -c <filename> save .csv file of blocks | |
| """ % (argv0)) | |
| sys.exit(2) | |
| def main(): | |
| signal.signal(signal.SIGPIPE, signal.SIG_DFL) | |
| me = posixpath.basename(sys.argv[0]) | |
| # Parse the command line | |
| verbose = 0 # -v | |
| showhash = 0 # -s | |
| csvfilename = None # -c | |
| try: | |
| opts, args = getopt.getopt(sys.argv[1:], | |
| "vsc:", | |
| ["verbose", "showhash", "csvfile"]) | |
| except getopt.GetoptError, e: | |
| print(e) | |
| usage(me) | |
| for o, a in opts: | |
| if o in ("-v", "--verbose"): | |
| verbose += 1 | |
| elif o in ("-s", "--showhash"): | |
| showhash = True | |
| elif o in ("-c", "--csvfile"): | |
| csvfilename = a | |
| else: | |
| print("Unrecognized option \"%s\"" % (o)) | |
| usage(me) | |
| if not args: | |
| print("No sparse_image_file specified") | |
| usage(me) | |
| if csvfilename: | |
| csvfile = open(csvfilename, "wb") | |
| csvwriter = csv.writer(csvfile) | |
| output = verbose or csvfilename or showhash | |
| for path in args: | |
| FH = open(path, "rb") | |
| header_bin = FH.read(28) | |
| header = struct.unpack("<I4H4I", header_bin) | |
| magic = header[0] | |
| major_version = header[1] | |
| minor_version = header[2] | |
| file_hdr_sz = header[3] | |
| chunk_hdr_sz = header[4] | |
| blk_sz = header[5] | |
| total_blks = header[6] | |
| total_chunks = header[7] | |
| image_checksum = header[8] | |
| if magic != 0xED26FF3A: | |
| print("%s: %s: Magic should be 0xED26FF3A but is 0x%08X" | |
| % (me, path, magic)) | |
| continue | |
| if major_version != 1 or minor_version != 0: | |
| print("%s: %s: I only know about version 1.0, but this is version %u.%u" | |
| % (me, path, major_version, minor_version)) | |
| continue | |
| if file_hdr_sz != 28: | |
| print("%s: %s: The file header size was expected to be 28, but is %u." | |
| % (me, path, file_hdr_sz)) | |
| continue | |
| if chunk_hdr_sz != 12: | |
| print("%s: %s: The chunk header size was expected to be 12, but is %u." | |
| % (me, path, chunk_hdr_sz)) | |
| continue | |
| print("%s: Total of %u %u-byte output blocks in %u input chunks." | |
| % (path, total_blks, blk_sz, total_chunks)) | |
| if image_checksum != 0: | |
| print("checksum=0x%08X" % (image_checksum)) | |
| if not output: | |
| continue | |
| if verbose > 0: | |
| print(" input_bytes output_blocks") | |
| print("chunk offset number offset number") | |
| if csvfilename: | |
| csvwriter.writerow(["chunk", "input offset", "input bytes", | |
| "output offset", "output blocks", "type", "hash"]) | |
| offset = 0 | |
| for i in xrange(1, total_chunks + 1): | |
| header_bin = FH.read(12) | |
| header = struct.unpack("<2H2I", header_bin) | |
| chunk_type = header[0] | |
| chunk_sz = header[2] | |
| total_sz = header[3] | |
| data_sz = total_sz - 12 | |
| curhash = "" | |
| curtype = "" | |
| curpos = FH.tell() | |
| if verbose > 0: | |
| print("%4u %10u %10u %7u %7u" % (i, curpos, data_sz, offset, chunk_sz), | |
| end=" ") | |
| if chunk_type == 0xCAC1: | |
| if data_sz != (chunk_sz * blk_sz): | |
| print("Raw chunk input size (%u) does not match output size (%u)" | |
| % (data_sz, chunk_sz * blk_sz)) | |
| break | |
| else: | |
| curtype = "Raw data" | |
| data = FH.read(data_sz) | |
| if showhash: | |
| h = hashlib.sha1() | |
| h.update(data) | |
| curhash = h.hexdigest() | |
| elif chunk_type == 0xCAC2: | |
| if data_sz != 4: | |
| print("Fill chunk should have 4 bytes of fill, but this has %u" | |
| % (data_sz)) | |
| break | |
| else: | |
| fill_bin = FH.read(4) | |
| fill = struct.unpack("<I", fill_bin) | |
| curtype = format("Fill with 0x%08X" % (fill)) | |
| if showhash: | |
| h = hashlib.sha1() | |
| data = fill_bin * (blk_sz / 4); | |
| for block in xrange(chunk_sz): | |
| h.update(data) | |
| curhash = h.hexdigest() | |
| elif chunk_type == 0xCAC3: | |
| if data_sz != 0: | |
| print("Don't care chunk input size is non-zero (%u)" % (data_sz)) | |
| break | |
| else: | |
| curtype = "Don't care" | |
| elif chunk_type == 0xCAC4: | |
| if data_sz != 4: | |
| print("CRC32 chunk should have 4 bytes of CRC, but this has %u" | |
| % (data_sz)) | |
| break | |
| else: | |
| crc_bin = FH.read(4) | |
| crc = struct.unpack("<I", crc_bin) | |
| curtype = format("Unverified CRC32 0x%08X" % (crc)) | |
| else: | |
| print("Unknown chunk type 0x%04X" % (chunk_type)) | |
| break | |
| if verbose > 0: | |
| print("%-18s" % (curtype), end=" ") | |
| if verbose > 1: | |
| header = struct.unpack("<12B", header_bin) | |
| print(" (%02X%02X %02X%02X %02X%02X%02X%02X %02X%02X%02X%02X)" | |
| % (header[0], header[1], header[2], header[3], | |
| header[4], header[5], header[6], header[7], | |
| header[8], header[9], header[10], header[11]), end=" ") | |
| print(curhash) | |
| if csvfilename: | |
| csvwriter.writerow([i, curpos, data_sz, offset, chunk_sz, curtype, | |
| curhash]) | |
| offset += chunk_sz | |
| if verbose > 0: | |
| print(" %10u %7u End" % (FH.tell(), offset)) | |
| if total_blks != offset: | |
| print("The header said we should have %u output blocks, but we saw %u" | |
| % (total_blks, offset)) | |
| junk_len = len(FH.read()) | |
| if junk_len: | |
| print("There were %u bytes of extra data at the end of the file." | |
| % (junk_len)) | |
| if csvfilename: | |
| csvfile.close() | |
| sys.exit(0) | |
| if __name__ == "__main__": | |
| main() |