Magisk/build.py

#!/usr/bin/env python3
import argparse
import glob
import lzma
import multiprocessing
import os
import platform
import shutil
import stat
import subprocess
import sys
import tarfile
import textwrap
import urllib.request
from pathlib import Path
from zipfile import ZipFile


def color_print(code, str):
    if no_color:
        print(str)
    else:
        str = str.replace("\n", f"\033[0m\n{code}")
        print(f"{code}{str}\033[0m")


def error(str):
    color_print("\033[41;39m", f"\n! {str}\n")
    sys.exit(1)


def header(str):
    color_print("\033[44;39m", f"\n{str}\n")


def vprint(str):
    if args.verbose > 0:
        print(str)


is_windows = os.name == "nt"
EXE_EXT = ".exe" if is_windows else ""

no_color = False
if is_windows:
    try:
        import colorama

        colorama.init()
    except ImportError:
        # We can't do ANSI color codes in terminal on Windows without colorama
        no_color = True

# Environment checks
if not sys.version_info >= (3, 8):
    error("Requires Python 3.8+")

try:
    sdk_path = Path(os.environ["ANDROID_HOME"])
except KeyError:
    try:
        sdk_path = Path(os.environ["ANDROID_SDK_ROOT"])
    except KeyError:
        error("Please set Android SDK path to environment variable ANDROID_HOME")

if shutil.which("sccache") is not None:
    os.environ["RUSTC_WRAPPER"] = "sccache"
    os.environ["NDK_CCACHE"] = "sccache"
    os.environ["CARGO_INCREMENTAL"] = "0"
if shutil.which("ccache") is not None:
    os.environ["NDK_CCACHE"] = "ccache"

cpu_count = multiprocessing.cpu_count()
os_name = platform.system().lower()

archs = ["armeabi-v7a", "x86", "arm64-v8a", "x86_64", "riscv64"]
triples = [
    "armv7a-linux-androideabi",
    "i686-linux-android",
    "aarch64-linux-android",
    "x86_64-linux-android",
    "riscv64-linux-android",
]
default_targets = {"magisk", "magiskinit", "magiskboot", "magiskpolicy"}
support_targets = default_targets | {"resetprop"}
rust_targets = {"magisk", "magiskinit", "magiskboot", "magiskpolicy"}

ndk_root = sdk_path / "ndk"
ndk_path = ndk_root / "magisk"
ndk_build = ndk_path / "ndk-build"
rust_bin = ndk_path / "toolchains" / "rust" / "bin"
llvm_bin = ndk_path / "toolchains" / "llvm" / "prebuilt" / f"{os_name}-x86_64" / "bin"
cargo = rust_bin / f"cargo{EXE_EXT}"
gradlew = Path("gradlew" + (".bat" if is_windows else "")).resolve()
adb_path = sdk_path / "platform-tools" / f"adb{EXE_EXT}"
native_gen_path = Path("native", "out", "generated").resolve()

# Global vars
config = {}
STDOUT = None
build_tools = None


def mv(source: Path, target: Path):
    try:
        shutil.move(source, target)
        vprint(f"mv {source} -> {target}")
    except:
        pass


def cp(source: Path, target: Path):
    try:
        shutil.copyfile(source, target)
        vprint(f"cp {source} -> {target}")
    except:
        pass


def rm(file: Path):
    try:
        os.remove(file)
        vprint(f"rm {file}")
    except FileNotFoundError as e:
        pass


def rm_on_error(func, path, _):
    # Removing a read-only file on Windows will get "WindowsError: [Error 5] Access is denied"
    # Clear the "read-only" bit and retry
    try:
        os.chmod(path, stat.S_IWRITE)
        os.unlink(path)
    except FileNotFoundError as e:
        pass


def rm_rf(path: Path):
    vprint(f"rm -rf {path}")
    shutil.rmtree(path, ignore_errors=False, onerror=rm_on_error)


def execv(cmd, env=None):
    return subprocess.run(cmd, stdout=STDOUT, env=env)


def system(cmd):
    return subprocess.run(cmd, shell=True, stdout=STDOUT)


def cmd_out(cmd, env=None):
    return (
        subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env)
        .stdout.strip()
        .decode("utf-8")
    )


def xz(data):
    return lzma.compress(data, preset=9, check=lzma.CHECK_NONE)


def parse_props(file):
    props = {}
    with open(file, "r") as f:
        for line in [l.strip(" \t\r\n") for l in f]:
            if line.startswith("#") or len(line) == 0:
                continue
            prop = line.split("=")
            if len(prop) != 2:
                continue
            value = prop[1].strip(" \t\r\n")
            if len(value) == 0:
                continue
            props[prop[0].strip(" \t\r\n")] = value
    return props


def load_config(args):
    commit_hash = cmd_out(["git", "rev-parse", "--short=8", "HEAD"])

    # Default values
    config["version"] = commit_hash
    config["versionCode"] = 1000000
    config["outdir"] = "out"

    args.config = Path(args.config)

    # Load prop files
    if args.config.exists():
        config.update(parse_props(args.config))

    if Path("gradle.properties").exists():
        for key, value in parse_props("gradle.properties").items():
            if key.startswith("magisk."):
                config[key[7:]] = value

    try:
        config["versionCode"] = int(config["versionCode"])
    except ValueError:
        error('Config error: "versionCode" is required to be an integer')

    config["outdir"] = Path(config["outdir"])

    config["outdir"].mkdir(mode=0o755, parents=True, exist_ok=True)
    global STDOUT
    STDOUT = None if args.verbose > 0 else subprocess.DEVNULL


def clean_elf():
    if is_windows:
        elf_cleaner = Path("tools", "elf-cleaner.exe")
    else:
        elf_cleaner = Path("native", "out", "elf-cleaner")
        if not elf_cleaner.exists():
            execv(
                [
                    "gcc",
                    '-DPACKAGE_NAME="termux-elf-cleaner"',
                    '-DPACKAGE_VERSION="2.1.1"',
                    '-DCOPYRIGHT="Copyright (C) 2022 Termux."',
                    "tools/termux-elf-cleaner/elf-cleaner.cpp",
                    "tools/termux-elf-cleaner/arghandling.c",
                    "-o",
                    elf_cleaner,
                ]
            )
    args = [elf_cleaner, "--api-level", "23"]
    args.extend(
        Path("native", "out", arch, bin)
        for arch in archs
        for bin in ["magisk", "magiskpolicy"]
    )
    execv(args)


def run_ndk_build(args, flags):
    os.chdir("native")
    flags = "NDK_PROJECT_PATH=. NDK_APPLICATION_MK=src/Application.mk " + flags
    if args.verbose > 1:
        flags = "V=1 " + flags
    proc = system(f"{ndk_build} {flags} -j{cpu_count}")
    if proc.returncode != 0:
        error("Build binary failed!")
    os.chdir("..")

    for arch in archs:
        arch_dir = Path("native", "libs", arch)
        out_dir = Path("native", "out", arch)
        for source in arch_dir.iterdir():
            target = out_dir / source.name
            mv(source, target)


def build_cpp_src(args, targets: set):
    dump_flag_header()

    flag = ""
    clean = False

    if "magisk" in targets:
        flag += " B_MAGISK=1"
        clean = True

    if "magiskpolicy" in targets:
        flag += " B_POLICY=1"
        clean = True

    if "magiskinit" in targets:
        flag += " B_PRELOAD=1"

    if "resetprop" in targets:
        flag += " B_PROP=1"

    if flag:
        run_ndk_build(args, flag)

    flag = ""

    if "magiskinit" in targets:
        # magiskinit embeds preload.so
        dump_bin_header(args)
        flag += " B_INIT=1"

    if "magiskboot" in targets:
        flag += " B_BOOT=1"

    if flag:
        flag += " B_CRT0=1"
        run_ndk_build(args, flag)

    if clean:
        clean_elf()


def run_cargo(cmds):
    env = os.environ.copy()
    env["PATH"] = f'{rust_bin}{os.pathsep}{env["PATH"]}'
    env["CARGO_BUILD_RUSTC"] = str(rust_bin / f"rustc{EXE_EXT}")
    env["RUSTFLAGS"] = f"-Clinker-plugin-lto -Zthreads={min(8, cpu_count)}"
    return execv([cargo, *cmds], env)


def build_rust_src(args, targets: set):
    targets = targets.copy()
    if "resetprop" in targets:
        targets.add("magisk")
    targets = targets & rust_targets
    if not targets:
        return

    os.chdir(Path("native", "src"))

    native_out = Path("..", "out")
    native_out.mkdir(mode=0o755, exist_ok=True)

    # Start building the actual build commands
    cmds = ["build", "-p", ""]
    rust_out = "debug"
    if args.release:
        cmds.append("-r")
        rust_out = "release"
    if args.verbose == 0:
        cmds.append("-q")
    elif args.verbose > 1:
        cmds.append("--verbose")

    cmds.append("--target")
    cmds.append("")

    for arch, triple in zip(archs, triples):
        rust_triple = (
            "thumbv7neon-linux-androideabi" if triple.startswith("armv7") else triple
        )
        cmds[-1] = rust_triple

        for tgt in targets:
            cmds[2] = tgt
            proc = run_cargo(cmds)
            if proc.returncode != 0:
                error("Build binary failed!")

        arch_out = native_out / arch
        arch_out.mkdir(mode=0o755, exist_ok=True)
        for tgt in targets:
            source = Path("target", rust_triple, rust_out, f"lib{tgt}.a")
            target = arch_out / f"lib{tgt}-rs.a"
            mv(source, target)

    os.chdir(Path("..", ".."))


def run_cargo_cmd(args):
    global STDOUT
    STDOUT = None
    if len(args.commands) >= 1 and args.commands[0] == "--":
        args.commands = args.commands[1:]
    os.chdir(Path("native", "src"))
    run_cargo(args.commands)
    os.chdir(Path("..", ".."))


def write_if_diff(file_name: Path, text: str):
    do_write = True
    if file_name.exists():
        with open(file_name, "r") as f:
            orig = f.read()
        do_write = orig != text
    if do_write:
        with open(file_name, "w") as f:
            f.write(text)


def binary_dump(src, var_name, compressor=xz):
    out_str = f"constexpr unsigned char {var_name}[] = {{"
    for i, c in enumerate(compressor(src.read())):
        if i % 16 == 0:
            out_str += "\n"
        out_str += f"0x{c:02X},"
    out_str += "\n};\n"
    return out_str


def dump_bin_header(args):
    native_gen_path.mkdir(mode=0o755, parents=True, exist_ok=True)
    for arch in archs:
        preload = Path("native", "out", arch, "libinit-ld.so")
        with open(preload, "rb") as src:
            text = binary_dump(src, "init_ld_xz")
        write_if_diff(Path(native_gen_path, f"{arch}_binaries.h"), text)


def dump_flag_header():
    flag_txt = textwrap.dedent(
        """\
        #pragma once
        #define quote(s)            #s
        #define str(s)              quote(s)
        #define MAGISK_FULL_VER     MAGISK_VERSION "(" str(MAGISK_VER_CODE) ")"
        #define NAME_WITH_VER(name) str(name) " " MAGISK_FULL_VER
        """
    )
    flag_txt += f'#define MAGISK_VERSION      "{config["version"]}"\n'
    flag_txt += f'#define MAGISK_VER_CODE     {config["versionCode"]}\n'
    flag_txt += f"#define MAGISK_DEBUG        {0 if args.release else 1}\n"

    native_gen_path.mkdir(mode=0o755, parents=True, exist_ok=True)
    write_if_diff(Path(native_gen_path, "flags.h"), flag_txt)


def build_binary(args):
    # Verify NDK install
    try:
        with open(Path(ndk_path, "ONDK_VERSION"), "r") as ondk_ver:
            assert ondk_ver.read().strip(" \t\r\n") == config["ondkVersion"]
    except:
        error('Unmatched NDK. Please install/upgrade NDK with "build.py ndk"')

    if "targets" not in vars(args) or not args.targets:
        targets = default_targets
    else:
        targets = set(args.targets) & support_targets
        if not targets:
            return

    header("* Building binaries: " + " ".join(targets))

    build_rust_src(args, targets)
    build_cpp_src(args, targets)


def find_jdk():
    env = os.environ.copy()
    if "ANDROID_STUDIO" in env:
        studio = env["ANDROID_STUDIO"]
        jbr = Path(studio, "jbr", "bin")
        if not jbr.exists():
            jbr = Path(studio, "Contents", "jbr", "Contents", "Home", "bin")
        if jbr.exists():
            env["PATH"] = f'{jbr}{os.pathsep}{env["PATH"]}'

    no_jdk = False
    try:
        proc = subprocess.run(
            "javac -version",
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            env=env,
            shell=True,
        )
        no_jdk = proc.returncode != 0
    except FileNotFoundError:
        no_jdk = True

    if no_jdk:
        error(
            "Please set Android Studio's path to environment variable ANDROID_STUDIO,\n"
            + "or install JDK 17 and make sure 'javac' is available in PATH"
        )

    return env


def build_apk(args, module):
    env = find_jdk()

    build_type = "Release" if args.release else "Debug"
    proc = execv(
        [
            gradlew,
            f"{module}:assemble{build_type}",
            f"-PconfigPath={args.config.resolve()}",
        ],
        env=env,
    )
    if proc.returncode != 0:
        error(f"Build {module} failed!")

    build_type = build_type.lower()

    paths = module.split(":")

    apk = f"{paths[-1]}-{build_type}.apk"
    source = Path(*paths, "build", "outputs", "apk", build_type, apk)
    target = config["outdir"] / apk
    mv(source, target)
    header(f"Output: {target}")


def build_app(args):
    header("* Building the Magisk app")
    build_apk(args, ":app:apk")

    build_type = "release" if args.release else "debug"

    # Rename apk-variant.apk to app-variant.apk
    source = config["outdir"] / f"apk-{build_type}.apk"
    target = config["outdir"] / f"app-{build_type}.apk"
    mv(source, target)

    # Stub building is directly integrated into the main app
    # build process. Copy the stub APK into output directory.
    source = Path("app", "core", "src", build_type, "assets", "stub.apk")
    target = config["outdir"] / f"stub-{build_type}.apk"
    cp(source, target)


def build_stub(args):
    header("* Building the stub app")
    build_apk(args, ":app:stub")


def cleanup(args):
    support_targets = {"native", "cpp", "rust", "java"}
    if args.targets:
        targets = set(args.targets) & support_targets
        if "native" in targets:
            targets.add("cpp")
            targets.add("rust")
    else:
        targets = support_targets

    if "cpp" in targets:
        header("* Cleaning C++")
        rm_rf(Path("native", "libs"))
        rm_rf(Path("native", "obj"))
        rm_rf(Path("native", "out"))

    if "rust" in targets:
        header("* Cleaning Rust")
        rm_rf(Path("native", "src", "target"))
        rm(Path("native", "src", "boot", "proto", "mod.rs"))
        rm(Path("native", "src", "boot", "proto", "update_metadata.rs"))
        for rs_gen in glob.glob("native/**/*-rs.*pp", recursive=True):
            rm(rs_gen)

    if "java" in targets:
        header("* Cleaning java")
        execv([gradlew, ":app:clean"], env=find_jdk())


def setup_ndk(args):
    ndk_ver = config["ondkVersion"]
    url = f"https://github.com/topjohnwu/ondk/releases/download/{ndk_ver}/ondk-{ndk_ver}-{os_name}.tar.xz"
    ndk_archive = url.split("/")[-1]
    ondk_path = Path(ndk_root, f"ondk-{ndk_ver}")

    header(f"* Downloading and extracting {ndk_archive}")
    rm_rf(ondk_path)
    with urllib.request.urlopen(url) as response:
        with tarfile.open(mode="r|xz", fileobj=response) as tar:
            if hasattr(tarfile, "data_filter"):
                tar.extractall(ndk_root, filter="tar")
            else:
                tar.extractall(ndk_root)

    rm_rf(ndk_path)
    mv(ondk_path, ndk_path)


def push_files(args, script):
    abi = cmd_out([adb_path, "shell", "getprop", "ro.product.cpu.abi"])
    if not abi:
        error("Cannot detect emulator ABI")

    apk = Path(
        config["outdir"], ("app-release.apk" if args.release else "app-debug.apk")
    )

    # Extract busybox from APK
    busybox = Path(config["outdir"], "busybox")
    with ZipFile(apk) as zf:
        with zf.open(f"lib/{abi}/libbusybox.so") as libbb:
            with open(busybox, "wb") as bb:
                bb.write(libbb.read())

    try:
        proc = execv([adb_path, "push", busybox, script, "/data/local/tmp"])
        if proc.returncode != 0:
            error("adb push failed!")
    finally:
        rm_rf(busybox)

    proc = execv([adb_path, "push", apk, "/data/local/tmp/magisk.apk"])
    if proc.returncode != 0:
        error("adb push failed!")


def setup_avd(args):
    if not args.skip:
        build_all(args)

    header("* Setting up emulator")

    push_files(args, Path("scripts", "avd_magisk.sh"))

    proc = execv([adb_path, "shell", "sh", "/data/local/tmp/avd_magisk.sh"])
    if proc.returncode != 0:
        error("avd_magisk.sh failed!")


def patch_avd_file(args):
    if not args.skip:
        build_all(args)

    input = Path(args.image)
    if args.output:
        output = Path(args.output)
    else:
        output = input.parent / f"{input.name}.magisk"

    src_file = f"/data/local/tmp/{input.name}"
    out_file = f"{src_file}.magisk"

    header(f"* Patching {input.name}")

    push_files(args, Path("scripts", "avd_patch.sh"))

    proc = execv([adb_path, "push", input, "/data/local/tmp"])
    if proc.returncode != 0:
        error("adb push failed!")

    proc = execv([adb_path, "shell", "sh", "/data/local/tmp/avd_patch.sh", src_file])
    if proc.returncode != 0:
        error("avd_patch.sh failed!")

    proc = execv([adb_path, "pull", out_file, output])
    if proc.returncode != 0:
        error("adb pull failed!")

    header(f"Output: {output}")


def build_all(args):
    build_binary(args)
    build_app(args)


def setup_rustup(args):
    wrapper_dir = Path(args.wrapper_dir)
    rm_rf(wrapper_dir)
    wrapper_dir.mkdir(mode=0o755, parents=True, exist_ok=True)
    if "CARGO_HOME" in os.environ:
        cargo_home = Path(os.environ["CARGO_HOME"])
    else:
        cargo_home = Path.home() / ".cargo"
    cargo_bin = cargo_home / "bin"
    for src in cargo_bin.iterdir():
        tgt = wrapper_dir / src.name
        tgt.symlink_to(src)

    # Build rustup_wrapper
    wrapper_src = Path("tools", "rustup_wrapper")
    cargo_toml = wrapper_src / "Cargo.toml"
    execv(
        [cargo, "build", "--release", f"--manifest-path={cargo_toml}"]
        + (["--verbose"] if args.verbose > 1 else [])
    )

    # Replace rustup with wrapper
    wrapper = wrapper_dir / (f"rustup{EXE_EXT}")
    wrapper.unlink(missing_ok=True)
    cp(wrapper_src / "target" / "release" / (f"rustup_wrapper{EXE_EXT}"), wrapper)
    wrapper.chmod(0o755)


parser = argparse.ArgumentParser(description="Magisk build script")
parser.set_defaults(func=lambda x: None)
parser.add_argument(
    "-r", "--release", action="store_true", help="compile in release mode"
)
parser.add_argument("-v", "--verbose", action="count", default=0, help="verbose output")
parser.add_argument(
    "-c",
    "--config",
    default="config.prop",
    help="custom config file (default: config.prop)",
)
subparsers = parser.add_subparsers(title="actions")

all_parser = subparsers.add_parser("all", help="build everything")
all_parser.set_defaults(func=build_all)

binary_parser = subparsers.add_parser("binary", help="build binaries")
binary_parser.add_argument(
    "targets",
    nargs="*",
    help=f"{', '.join(support_targets)}, \
    or empty for defaults ({', '.join(default_targets)})",
)
binary_parser.set_defaults(func=build_binary)

cargo_parser = subparsers.add_parser("cargo", help="run cargo with proper environment")
cargo_parser.add_argument("commands", nargs=argparse.REMAINDER)
cargo_parser.set_defaults(func=run_cargo_cmd)

rustup_parser = subparsers.add_parser("rustup", help="setup rustup wrapper")
rustup_parser.add_argument("wrapper_dir", help="path to setup rustup wrapper binaries")
rustup_parser.set_defaults(func=setup_rustup)

app_parser = subparsers.add_parser("app", help="build the Magisk app")
app_parser.set_defaults(func=build_app)

stub_parser = subparsers.add_parser("stub", help="build the stub app")
stub_parser.set_defaults(func=build_stub)

avd_parser = subparsers.add_parser("emulator", help="setup AVD for development")
avd_parser.add_argument(
    "-s", "--skip", action="store_true", help="skip building binaries and the app"
)
avd_parser.set_defaults(func=setup_avd)

avd_patch_parser = subparsers.add_parser(
    "avd_patch", help="patch AVD ramdisk.img or init_boot.img"
)
avd_patch_parser.add_argument("image", help="path to ramdisk.img or init_boot.img")
avd_patch_parser.add_argument("output", help="optional output file name", nargs="?")
avd_patch_parser.add_argument(
    "-s", "--skip", action="store_true", help="skip building binaries and the app"
)
avd_patch_parser.set_defaults(func=patch_avd_file)

clean_parser = subparsers.add_parser("clean", help="cleanup")
clean_parser.add_argument(
    "targets", nargs="*", help="native, cpp, rust, java, or empty to clean all"
)
clean_parser.set_defaults(func=cleanup)

ndk_parser = subparsers.add_parser("ndk", help="setup Magisk NDK")
ndk_parser.set_defaults(func=setup_ndk)

if len(sys.argv) == 1:
    parser.print_help()
    sys.exit(1)

args = parser.parse_args()
load_config(args)

# Call corresponding functions
args.func(args)