#!/usr/bin/env python2.7 # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. # This script is used to create and manipulate archives containing # files necessary to build Firefox on Windows (referred to as the # "Windows toolchain"). # # When updating behavior of this script, remember to update the docs # in ``build/docs/toolchains.rst``. from __future__ import absolute_import, unicode_literals import hashlib import os import sys from mozpack.files import FileFinder from mozpack.mozjar import JarWriter import mozpack.path as mozpath SDK_RELEASE = "10.0.17134.0" PATTERNS = [ { "srcdir": "%(vs_path)s/DIA SDK", "dstdir": "DIA SDK", "files": [ { "pattern": "bin/**", "ignore": ("bin/arm/**",), }, { "pattern": "idl/**", }, { "pattern": "include/**", }, { "pattern": "lib/**", "ignore": ("lib/arm/**",), }, ], }, { "srcdir": "%(vs_path)s/VC/Tools/MSVC/14.16.27023", "dstdir": "VC", "files": [ # ATL is needed by Breakpad. { "pattern": "atlmfc/include/**", }, { "pattern": "atlmfc/lib/arm64/atls.*", }, { "pattern": "atlmfc/lib/x64/atls.*", }, { "pattern": "atlmfc/lib/x86/atls.*", }, # ARM64 PGO-instrumented builds require ARM64 pgort140.dll. { "pattern": "bin/arm64/pgort140.dll", }, { "pattern": "bin/Hostx64/**", }, # 32-bit PGO-instrumented builds require 32-bit pgort140.dll. { "pattern": "bin/Hostx86/x86/pgort140.dll", }, { "pattern": "include/**", }, { "pattern": "lib/**", "ignore": ( "lib/arm64/store/**", "lib/onecore/**", "lib/x64/store/**", "lib/x86/store/**", ), }, ], }, { "srcdir": "%(vs_path)s/VC/Redist/MSVC/14.16.27012", "dstdir": "VC/redist", "files": [ { "pattern": "arm64/Microsoft.VC141.CRT/**", }, { "pattern": "x64/Microsoft.VC141.CRT/**", }, { "pattern": "x86/Microsoft.VC141.CRT/**", }, ], }, { "srcdir": "%(sdk_path)s", "dstdir": "SDK", "files": [ { "pattern": "bin/%s/x64/**" % SDK_RELEASE, }, { "pattern": "Include/%s/**" % SDK_RELEASE, }, { "pattern": "Lib/%s/ucrt/arm64/**" % SDK_RELEASE, }, { "pattern": "Lib/%s/ucrt/x64/**" % SDK_RELEASE, }, { "pattern": "Lib/%s/ucrt/x86/**" % SDK_RELEASE, }, { "pattern": "Lib/%s/um/arm64/**" % SDK_RELEASE, }, { "pattern": "Lib/%s/um/x64/**" % SDK_RELEASE, }, { "pattern": "Lib/%s/um/x86/**" % SDK_RELEASE, }, { "pattern": "Redist/D3D/**", }, { "pattern": "Redist/ucrt/DLLs/x64/**", }, { "pattern": "Redist/ucrt/DLLs/x86/**", }, ], }, ] def find_vs_paths(): """Resolve source locations of files. Returns a 2-tuple of (Visual Studio Path, SDK Path). """ pf = os.environ.get("ProgramFiles(x86)") if not pf: raise Exception( 'No "ProgramFiles(x86)" environment variable. ' "Not running on 64-bit Windows?" ) vs_path = os.path.join(pf, "Microsoft Visual Studio", "2017", "Community") if not os.path.exists(vs_path): raise Exception( "%s does not exist; Visual Studio 2017 not installed?" % vs_path ) sdk_path = os.path.join(pf, "Windows Kits", "10") if not os.path.exists(sdk_path): raise Exception("%s does not exist; Windows 10 SDK not installed?" % sdk_path) sdk_fullver_path = os.path.join(sdk_path, "Include", SDK_RELEASE) if not os.path.exists(sdk_fullver_path): raise Exception( "%s does not exist; Wrong SDK version installed?" % sdk_fullver_path ) return vs_path, sdk_path def resolve_files(): """Resolve the files that constitute a standalone toolchain. This is a generator of (dest path, file) where the destination path is relative and the file instance is a BaseFile from mozpack. """ vs_path, sdk_path = find_vs_paths() for entry in PATTERNS: fullpath = entry["srcdir"] % { "vs_path": vs_path, "sdk_path": sdk_path, } for pattern in entry["files"]: finder = FileFinder(fullpath, ignore=pattern.get("ignore", [])) for p, f in finder.find(pattern["pattern"]): dstpath = "%s/%s" % (entry["dstdir"], p) yield dstpath.encode("utf-8"), f def resolve_files_and_hash(manifest): """Resolve files and hash their data. This is a generator of 3-tuples of (relpath, data, mode). As data is read, the manifest is populated with metadata. Keys are set to the relative file path. Values are 2-tuples of (data length, sha-256). """ assert manifest == {} for p, f in resolve_files(): data = f.read() sha256 = hashlib.sha256() sha256.update(data) manifest[p] = (len(data), sha256.hexdigest()) yield p, data, f.mode def format_manifest(manifest): """Return formatted SHA-256 manifests as a byte strings.""" sha256_lines = [] for path, (length, sha256) in sorted(manifest.items()): sha256_lines.append(b"%s\t%d\t%s" % (sha256, length, path)) # Trailing newline. sha256_lines.append(b"") return b"\n".join(sha256_lines) def write_zip(zip_path, prefix=None): """Write toolchain data to a zip file.""" if isinstance(prefix, unicode): # noqa Special case for Python 2 prefix = prefix.encode("utf-8") with JarWriter(file=zip_path, compress_level=5) as zip: manifest = {} for p, data, mode in resolve_files_and_hash(manifest): print(p) if prefix: p = mozpath.join(prefix, p) zip.add(p, data, mode=mode) sha256_manifest = format_manifest(manifest) sdk_path = b"SDK_VERSION" sha256_path = b"MANIFEST.SHA256" if prefix: sdk_path = mozpath.join(prefix, sdk_path) sha256_path = mozpath.join(prefix, sha256_path) zip.add(sdk_path, SDK_RELEASE.encode("utf-8")) zip.add(sha256_path, sha256_manifest) if __name__ == "__main__": if len(sys.argv) != 3: print("usage: %s create-zip " % sys.argv[0]) sys.exit(1) assert sys.argv[1] == "create-zip" prefix = os.path.basename(sys.argv[2]) destzip = "%s.zip" % sys.argv[2] write_zip(destzip, prefix=prefix) sha1 = hashlib.sha1() sha256 = hashlib.sha256() sha512 = hashlib.sha512() with open(destzip, "rb") as fh: data = fh.read() sha1.update(data) sha256.update(data) sha512.update(data) print("Hashes of %s (size=%d)" % (destzip, len(data))) print("SHA-1: %s" % sha1.hexdigest()) print("SHA-256: %s" % sha256.hexdigest()) print("SHA-512: %s" % sha512.hexdigest())