Bump Magisk Manager version

Introduce monogisk tool

.gitattributes

@@ -8,9 +8,11 @@
 
 # Declare files that will always have CRLF line endings on checkout.
 *.cmd text eol=crlf
+*.bat text eol=crlf
 
 # Denote all files that are truly binary and should not be modified.
 chromeos/** binary
 *.jar binary
 *.exe binary
 *.apk binary
+*.png binary

.gitignore

@@ -1,7 +1,9 @@
+out/
 obj/
 libs/
 *.zip
 *.jks
+*.apk
 
-# Copied binaries
+# Built binaries
 ziptools/zipadjust

.gitmodules

@@ -1,15 +1,27 @@
 [submodule "jni/selinux"]
-	path = jni/selinux
+	path = jni/external/selinux
 	url = https://github.com/topjohnwu/selinux.git
 [submodule "jni/su"]
 	path = jni/su
 	url = https://github.com/topjohnwu/MagiskSU.git
-[submodule "jni/ndk-compression"]
-	path = jni/ndk-compression
-	url = https://github.com/topjohnwu/ndk-compression.git
 [submodule "jni/magiskpolicy"]
 	path = jni/magiskpolicy
 	url = https://github.com/topjohnwu/magiskpolicy.git
 [submodule "MagiskManager"]
-	path = MagiskManager
+	path = java
 	url = https://github.com/topjohnwu/MagiskManager.git
+[submodule "jni/busybox"]
+	path = jni/external/busybox
+	url = https://github.com/topjohnwu/ndk-busybox.git
+[submodule "jni/external/dtc"]
+	path = jni/external/dtc
+	url = https://github.com/dgibson/dtc
+[submodule "jni/external/lz4"]
+	path = jni/external/lz4
+	url = https://github.com/lz4/lz4.git
+[submodule "jni/external/bzip2"]
+	path = jni/external/bzip2
+	url = https://github.com/nemequ/bzip2.git
+[submodule "jni/external/xz"]
+	path = jni/external/xz
+	url = https://github.com/xz-mirror/xz.git

README.MD

@@ -2,35 +2,32 @@
 
 ## How to build Magisk
 
-#### Building has been tested on 3 major platforms:
+#### Building has been tested on 3 major platforms: macOS, Ubuntu, Windows 10
 
-***macOS 10.12.5***  
-***Ubuntu 17.04 x64***  
-***Windows 10 Creators Update x64***  
+### Environment Requirements
 
-#### Environment Requirements
+1. A 64-bit machine: `cmake` for Android is only available in 64-bit
+2. Python 3.5+: run `build.py` script
+3. Java Development Kit (JDK) 8: Compile Magisk Manager and sign zips
+4. Latest Android SDK: `ANDROID_HOME` environment variable should point to the Android SDK folder
+5. Android NDK: Install NDK along with SDK (`$ANDROID_HOME/ndk-bundle`), or specify custom path `ANDROID_NDK`
+6. (Windows Only) Colorama: Install Colorama with `pip install colorama`, used for ANSI color codes
+7. (Unix only) C compiler: Build `zipadjust`. Windows users can use the pre-built `zipadjust.exe`
 
-1. Python 3 **(>= 3.5)**: `python3` (or in some cases `python`) should be accessible  
-2. Java runtime: `java` should be accessible  
-3. (Unix only) C compiler: `gcc` should be accessible  
-4. Android SDK: `ANDROID_HOME` environment variable should point to the Android SDK folder  
-5. NDK: Install NDK using `sdkmanager`, or through Android SDK Manager  
-6. Android build-tools: Should have build-tools version matching `MagiskManager/app/build.gradle` installed  
+### Instructions and Notes
+1. Magisk can be built with the latest NDK (r16 as of writing), however official released binaries will be built with NDK r10e due to ELF incompatibilities with the binaries built from newer NDKs.
+2. The easiest way to setup a working environment is to open Magisk Manager with Android Studio. The IDE will download required components and construct the environment for you. Don't forget to set `ANDROID_HOME` environment variable to the SDK path.
+3. Run the script with `-h` as an argument to see the built-in help message. The `-h` option also works for each supported actions, e.g. `./build.py binary -h`
+4. By default, the script will build binaries and Magisk Manager in debug mode. If you want to build Magisk Manager in release mode (through the flag `--release`), you will need to place your Java Keystore file at `release_signature.jks` to sign Magisk Manager's APK. For more information, check out [Google's Official Documentation](https://developer.android.com/studio/publish/app-signing.html#signing-manually).
 
-#### Instructions and Notes
-
-1. The python build script uses ANSI color codes to change the color of the terminal output. For Windows, this **only** works on Windows 10, as previous Windows console do not support them. If you insist to use an older Windows version, a quick Google search should provide many workarounds  
-2. After installing the latest Python 3 on Windows (allow the installer to add Python to PATH, or you'll have to manually set the environment), instead of calling `python3` like most Unix environment, you should call `python` in shell (cmd or Powershell both OK). You can double check the version by `python --version`  
-3. The build script will do several checks, it will refuse to run if the environment doesn't meet the requirements  
-4. For further instructions, please check the built in help message by `python3 build.py -h`  
-(Unix users can simply `./build.py -h`, Windows users, as mentioned, call `python` instead)  
-5. Each action has its own help message, access them by commands like `python3 build.py all -h`  
-6. To build Magisk for release (enabled through the `--release` flag, the script builds in debug mode by default), you will need to provide a Java keystore file, and place it in `release_signature.jks` to sign Magisk Manager APK for release builds. For more information, check out [Google's Official Documentation](https://developer.android.com/studio/publish/app-signing.html#signing-manually)
-7. To properly setup the Android SDK environment, the easiest way is to use Android Studio and open Magisk Manager. If gradle sync passed, your build-tools etc. should be set properly. You can also access SDK Manager GUI within Android Studio to download NDK. Don't forget to add Android Studio's SDK path into environment variable ANDROID_HOME.  
 
 ## License
 
-Magisk, including all subprojects (git submodule) is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+```
+Magisk, including all git submodules are free software:
+you can redistribute it and/or modify it under the terms of the 
+GNU General Public License as published by the Free Software Foundation, 
+either version 3 of the License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -39,14 +36,17 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
+```
 
 ## Credits
 
-**MagiskManager** (`MagiskManager`)
+**MagiskManager** (`java`)
+
 * Copyright 2016-2017, John Wu (@topjohnwu)
 * All contributors and translators
 
 **MagiskSU** (`jni/su`)
+
 * Copyright 2016-2017, John Wu (@topjohnwu)
 * Copyright 2015, Pierre-Hugues Husson (phh@phh.me)
 * Copyright 2013, Koushik Dutta (@koush)
@@ -54,25 +54,27 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * Copyright 2008, Zinx Verituse (@zinxv)
 
 **MagiskPolicy** (`jni/magiskpolicy`)
+
 * Copyright 2016-2017, John Wu (@topjohnwu)
 * Copyright 2015, Pierre-Hugues Husson (phh@phh.me)
 * Copyright 2015, Joshua Brindle (@joshua_brindle)
 
 **MagiskHide** (`jni/magiskhide`)
+
 * Copyright 2016-2017, John Wu (@topjohnwu)
-* Copyright 2016, Pierre-Hugues Husson (phh@phh.me) (original hidesu)
+* Copyright 2016, Pierre-Hugues Husson (phh@phh.me)
 
 **resetprop** (`jni/resetprop`)
+
  * Copyright 2016-2017 John Wu (@topjohnwu)
  * Copyright 2016 nkk71 (nkk71x@gmail.com)
- 
-**SELinux** (`jni/selinux`)
-* Makefile for NDK: Copyright 2016-2017, John Wu (@topjohnwu)
-* It is maintained by many developers in SELinux project, copyright belongs to them
 
-**ndk-compression** (`jni/ndk-compression`)
-* Makefile for NDK: Copyright 2017, John Wu (@topjohnwu)
-* Each library has its own copyright message in each directories
+**ndk-busybox** (`jni/external/busybox`)
+
+* Makefile for NDK, generated by [ndk-busybox-kitchen](https://github.com/topjohnwu/ndk-busybox-kitchen): Copyright 2017, John Wu (@topjohnwu)
+* Patches for NDK: Many contributors along the way, all placed in [osm0sis/android-busybox-ndk](https://github.com/osm0sis/android-busybox-ndk)
+* The copyright message for busybox should be included in its own directory
+
+**Others Not Mentioned** (exclude `jni/external`)
 
-**Others Not Mentioned**
 * Copyright 2016-2017, John Wu (@topjohnwu)

build.py

@@ -3,6 +3,10 @@ import sys
 import os
 import subprocess
 
+if os.name == 'nt':
+	from colorama import init
+	init()
+
 def error(str):
 	print('\n' + '\033[41m' + str + '\033[0m' + '\n')
 	sys.exit(1)
@@ -34,18 +38,39 @@ import multiprocessing
 import zipfile
 import datetime
 import errno
+import shutil
+import lzma
+import base64
+import tempfile
 
-def silentremove(file):
+def mv(source, target):
+	print('mv: {} -> {}'.format(source, target))
+	shutil.move(source, target)
+
+def cp(source, target):
+	print('cp: {} -> {}'.format(source, target))
+	shutil.copyfile(source, target)
+
+def rm(file):
 	try:
 	    os.remove(file)
 	except OSError as e:
 		if e.errno != errno.ENOENT:
 			raise
 
+def mkdir(path, mode=0o777):
+	try:
+		os.mkdir(path, mode)
+	except:
+		pass
+
+def mkdir_p(path, mode=0o777):
+	os.makedirs(path, mode, exist_ok=True)
+
 def zip_with_msg(zipfile, source, target):
 	if not os.path.exists(source):
 		error('{} does not exist! Try build \'binary\' and \'apk\' before zipping!'.format(source))
-	print('zip: ' + source + ' -> ' + target)
+	print('zip: {} -> {}'.format(source, target))
 	zipfile.write(source, target)
 
 def build_all(args):
@@ -53,129 +78,211 @@ def build_all(args):
 	build_apk(args)
 	zip_main(args)
 	zip_uninstaller(args)
+	build_snet(args)
 
 def build_binary(args):
 	header('* Building Magisk binaries')
 
-	ndk_build = os.path.join(os.environ['ANDROID_HOME'], 'ndk-bundle', 'ndk-build')
-	debug_flag = '' if args.release else '-DDEBUG'
-	proc = subprocess.run('{} APP_CFLAGS=\"-DMAGISK_VERSION=\\\"{}\\\" -DMAGISK_VER_CODE={} {}\" -j{}'.format(
-		ndk_build, args.versionString, args.versionCode, debug_flag, multiprocessing.cpu_count()), shell=True)
+	# Force update Android.mk timestamp to trigger recompilation
+	os.utime(os.path.join('jni', 'Android.mk'))
+
+	debug_flag = '' if args.release else '-DMAGISK_DEBUG'
+	cflag = 'MAGISK_FLAGS=\"-DMAGISK_VERSION=\\\"{}\\\" -DMAGISK_VER_CODE={} {}\"'.format(args.versionString, args.versionCode, debug_flag)
+
+	if 'ANDROID_NDK' in os.environ:
+		ndk_build = os.path.join(os.environ['ANDROID_NDK'], 'ndk-build')
+	else:
+		ndk_build = os.path.join(os.environ['ANDROID_HOME'], 'ndk-bundle', 'ndk-build')
+
+	# Prebuild
+	proc = subprocess.run('{} PRECOMPILE=true {} -j{}'.format(ndk_build, cflag, multiprocessing.cpu_count()), shell=True)
 	if proc.returncode != 0:
 		error('Build Magisk binary failed!')
 
+	print('')
+	for arch in ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']:
+		mkdir_p(os.path.join('out', arch))
+		with open(os.path.join('out', arch, 'dump.h'), 'w') as dump:
+			dump.write('#include "stdlib.h"\n')
+			mv(os.path.join('libs', arch, 'magisk'), os.path.join('out', arch, 'magisk'))
+			with open(os.path.join('out', arch, 'magisk'), 'rb') as bin:
+				dump.write('const uint8_t magisk_dump[] = "')
+				dump.write(''.join("\\x{:02X}".format(c) for c in lzma.compress(bin.read(), preset=9)))
+				dump.write('";\n')
+
+	print('')
+
+	proc = subprocess.run('{} {} -j{}'.format(ndk_build, cflag, multiprocessing.cpu_count()), shell=True)
+	if proc.returncode != 0:
+		error('Build Magisk binary failed!')
+
+	print('')
+	for arch in ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']:
+		for binary in ['magiskinit', 'magiskboot', 'b64xz', 'busybox']:
+			try:
+				mv(os.path.join('libs', arch, binary), os.path.join('out', arch, binary))
+			except:
+				pass
+
 def build_apk(args):
 	header('* Building Magisk Manager')
 
-	os.chdir('MagiskManager')
+	for key in ['public.certificate.x509.pem', 'private.key.pk8']:
+		source = os.path.join('ziptools', key)
+		target = os.path.join('java', 'app', 'src', 'main', 'assets', key)
+		cp(source, target)
+
+	for script in ['magisk_uninstaller.sh', 'util_functions.sh']:
+		source = os.path.join('scripts', script)
+		target = os.path.join('java', 'app', 'src', 'main', 'assets', script)
+		cp(source, target)
+
+	os.chdir('java')
+
 	if args.release:
 		if not os.path.exists(os.path.join('..', 'release_signature.jks')):
 			error('Please generate a java keystore and place it in \'release_signature.jks\'')
 
-		proc = subprocess.run('{} assembleRelease'.format(os.path.join('.', 'gradlew')), shell=True)
+		proc = subprocess.run('{} app:assembleRelease'.format(os.path.join('.', 'gradlew')), shell=True)
 		if proc.returncode != 0:
 			error('Build Magisk Manager failed!')
 
-		unsigned = os.path.join('app', 'build', 'outputs', 'apk', 'app-release-unsigned.apk')
-		aligned = os.path.join('app', 'build', 'outputs', 'apk', 'app-release-aligned.apk')
-		release = os.path.join('app', 'build', 'outputs', 'apk', 'app-release.apk')
+		unsigned = os.path.join('app', 'build', 'outputs', 'apk', 'release', 'app-release-unsigned.apk')
+		aligned = os.path.join('app', 'build', 'outputs', 'apk', 'release', 'app-release-aligned.apk')
+		release = os.path.join('app', 'build', 'outputs', 'apk', 'release', 'app-release.apk')
 
 		# Find the latest build tools
 		build_tool = sorted(os.listdir(os.path.join(os.environ['ANDROID_HOME'], 'build-tools')))[-1]
 
-		silentremove(aligned)
-		silentremove(release)
+		rm(aligned)
+		rm(release)
 
 		proc = subprocess.run([
 			os.path.join(os.environ['ANDROID_HOME'], 'build-tools', build_tool, 'zipalign'),
-			'-v', '-p', '4', unsigned, aligned])
+			'-v', '-p', '4', unsigned, aligned], stdout=subprocess.DEVNULL)
 		if proc.returncode != 0:
 			error('Zipalign Magisk Manager failed!')
 
-		proc = subprocess.run('{} sign --ks {} --out {} {}'.format(
-			os.path.join(os.environ['ANDROID_HOME'], 'build-tools', build_tool, 'apksigner'),
+		# Find apksigner.jar
+		apksigner = ''
+		for root, dirs, files in os.walk(os.path.join(os.environ['ANDROID_HOME'], 'build-tools', build_tool)):
+			if 'apksigner.jar' in files:
+				apksigner = os.path.join(root, 'apksigner.jar')
+				break
+		if not apksigner:
+			error('Cannot find apksigner.jar in Android SDK build tools')
+
+		proc = subprocess.run('java -jar {} sign --ks {} --out {} {}'.format(
+			apksigner,
 			os.path.join('..', 'release_signature.jks'),
 			release, aligned), shell=True)
 		if proc.returncode != 0:
 			error('Release sign Magisk Manager failed!')
 
-		silentremove(unsigned)
-		silentremove(aligned)
+		rm(unsigned)
+		rm(aligned)
+
+		mkdir(os.path.join('..', 'out'))
+		target = os.path.join('..', 'out', 'app-release.apk')
+		print('')
+		mv(release, target)
 	else:
-		proc = subprocess.run('{} assembleDebug'.format(os.path.join('.', 'gradlew')), shell=True)
+		proc = subprocess.run('{} app:assembleDebug'.format(os.path.join('.', 'gradlew')), shell=True)
 		if proc.returncode != 0:
 			error('Build Magisk Manager failed!')
 
+		source = os.path.join('app', 'build', 'outputs', 'apk', 'debug', 'app-debug.apk')
+		mkdir(os.path.join('..', 'out'))
+		target = os.path.join('..', 'out', 'app-debug.apk')
+		print('')
+		mv(source, target)
+
 	# Return to upper directory
 	os.chdir('..')
 
-def sign_adjust_zip(unsigned, output):
-	header('* Signing / Adjusting Zip')
-
-	# Unsigned->signed
-	proc = subprocess.run(['java', '-jar', os.path.join('ziptools', 'signapk.jar'), 
-		os.path.join('ziptools', 'test.certificate.x509.pem'), 
-		os.path.join('ziptools', 'test.key.pk8'), unsigned, 'tmp_signed.zip'])
+def build_snet(args):
+	os.chdir('java')
+	proc = subprocess.run('{} snet:assembleRelease'.format(os.path.join('.', 'gradlew')), shell=True)
 	if proc.returncode != 0:
-		error('First sign flashable zip failed!')
+		error('Build snet extention failed!')
+	source = os.path.join('snet', 'build', 'outputs', 'apk', 'release', 'snet-release-unsigned.apk')
+	mkdir(os.path.join('..', 'out'))
+	target = os.path.join('..', 'out', 'snet.apk')
+	print('')
+	mv(source, target)
+	os.chdir('..')
 
-	if os.name != 'nt' and not os.path.exists(os.path.join('ziptools', 'zipadjust')):
-		# Compile zipadjust
-		proc = subprocess.run('gcc -o ziptools/zipadjust ziptools/src/*.c -lz', shell=True)
-		if proc.returncode != 0:
-			error('Build zipadjust failed!')
-
-	# Adjust zip
-	proc = subprocess.run([os.path.join('ziptools', 'zipadjust'), 'tmp_signed.zip', 'tmp_adjusted.zip'])
-	if proc.returncode != 0:
-		error('Adjust flashable zip failed!')
-
-	# Adjusted -> output
-	proc = subprocess.run(['java', '-jar', os.path.join('ziptools', 'minsignapk.jar'), 
-		os.path.join('ziptools', 'test.certificate.x509.pem'), 
-		os.path.join('ziptools', 'test.key.pk8'), 'tmp_adjusted.zip', output])
-	if proc.returncode != 0:
-		error('Second sign flashable zip failed!')
-
-	# Cleanup
-	silentremove(unsigned)
-	silentremove('tmp_signed.zip')
-	silentremove('tmp_adjusted.zip')
+def gen_update_binary():
+	update_bin = []
+	binary = os.path.join('out', 'armeabi-v7a', 'b64xz')
+	if not os.path.exists(binary):
+		error('Please build \'binary\' before zipping!')
+	with open(binary, 'rb') as b64xz:
+		update_bin.append('#! /sbin/sh\nEX_ARM=\'')
+		update_bin.append(''.join("\\x{:02X}".format(c) for c in b64xz.read()))
+	binary = os.path.join('out', 'x86', 'b64xz')
+	with open(binary, 'rb') as b64xz:
+		update_bin.append('\'\nEX_X86=\'')
+		update_bin.append(''.join("\\x{:02X}".format(c) for c in b64xz.read()))
+	binary = os.path.join('out', 'armeabi-v7a', 'busybox')
+	with open(binary, 'rb') as busybox:
+		update_bin.append('\'\nBB_ARM=')
+		update_bin.append(base64.b64encode(lzma.compress(busybox.read(), preset=9)).decode('ascii'))
+	binary = os.path.join('out', 'x86', 'busybox')
+	with open(binary, 'rb') as busybox:
+		update_bin.append('\nBB_X86=')
+		update_bin.append(base64.b64encode(lzma.compress(busybox.read(), preset=9)).decode('ascii'))
+		update_bin.append('\n')
+	with open(os.path.join('scripts', 'update_binary.sh'), 'r') as script:
+		update_bin.append(script.read())
+	return ''.join(update_bin)
 
 def zip_main(args):
 	header('* Packing Flashable Zip')
 
-	with zipfile.ZipFile('tmp_unsigned.zip', 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
-		# Compiled Binaries
+	unsigned = tempfile.mkstemp()[1]
+
+	with zipfile.ZipFile(unsigned, 'w', compression=zipfile.ZIP_DEFLATED, allowZip64=False) as zipf:
+		# META-INF
+		# update-binary
+		target = os.path.join('META-INF', 'com', 'google', 'android', 'update-binary')
+		print('zip: ' + target)
+		zipf.writestr(target, gen_update_binary())
+		# updater-script
+		source = os.path.join('scripts', 'flash_script.sh')
+		target = os.path.join('META-INF', 'com', 'google', 'android', 'updater-script')
+		zip_with_msg(zipf, source, target)
+
+		# Binaries
 		for lib_dir, zip_dir in [('arm64-v8a', 'arm64'), ('armeabi-v7a', 'arm'), ('x86', 'x86'), ('x86_64', 'x64')]:
-			for binary in ['magisk', 'magiskboot']:
-				source = os.path.join('libs', lib_dir, binary)
+			for binary in ['magiskinit', 'magiskboot']:
+				source = os.path.join('out', lib_dir, binary)
 				target = os.path.join(zip_dir, binary)
 				zip_with_msg(zipf, source, target)
 
 		# APK
-		source = os.path.join('MagiskManager', 'app', 'build', 'outputs', 'apk', 'app-release.apk' if args.release else 'app-debug.apk')
+		source = os.path.join('out', 'app-release.apk' if args.release else 'app-debug.apk')
 		target = os.path.join('common', 'magisk.apk')
 		zip_with_msg(zipf, source, target)
 
 		# Scripts
-		source = os.path.join('scripts', 'flash_script.sh')
-		with open(source, 'r') as flash_script:
-			# Add version info into flash script
-			update_binary = flash_script.read().replace(
-				'MAGISK_VERSION_STUB', 'Magisk v{} Installer'.format(args.versionString))
-			target = os.path.join('META-INF', 'com', 'google', 'android', 'update-binary')
-			print('zip: ' + source + ' -> ' + target)
-			zipf.writestr(target, update_binary)
-		target = os.path.join('META-INF', 'com', 'google', 'android', 'updater-script')
-		print('zip: ' + target)
-		zipf.writestr(target, '#MAGISK\n')
-		source = os.path.join('scripts', 'init.magisk.rc')
-		target = os.path.join('common', 'init.magisk.rc')
-		zip_with_msg(zipf, source, target)
+		# boot_patch.sh
 		source = os.path.join('scripts', 'boot_patch.sh')
 		target = os.path.join('common', 'boot_patch.sh')
 		zip_with_msg(zipf, source, target)
+		# util_functions.sh
+		source = os.path.join('scripts', 'util_functions.sh')
+		with open(source, 'r') as script:
+			# Add version info util_functions.sh
+			util_func = script.read().replace(
+				'MAGISK_VERSION_STUB', 'MAGISK_VER="{}"\nMAGISK_VER_CODE={}'.format(args.versionString, args.versionCode))
+			target = os.path.join('common', 'util_functions.sh')
+			print('zip: ' + source + ' -> ' + target)
+			zipf.writestr(target, util_func)
+		# addon.d.sh
+		source = os.path.join('scripts', 'addon.d.sh')
+		target = os.path.join('addon.d', '99-magisk.sh')
+		zip_with_msg(zipf, source, target)
 
 		# Prebuilts
 		for chromeos in ['futility', 'kernel_data_key.vbprivk', 'kernel.keyblock']:
@@ -184,16 +291,28 @@ def zip_main(args):
 
 		# End of zipping
 
-	output = 'Magisk-v{}.zip'.format(args.versionString)
-	sign_adjust_zip('tmp_unsigned.zip', output)
+	output = os.path.join('out', 'Magisk-v{}.zip'.format(args.versionString))
+	sign_adjust_zip(unsigned, output)
 
 def zip_uninstaller(args):
 	header('* Packing Uninstaller Zip')
 
-	with zipfile.ZipFile('tmp_unsigned.zip', 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
-		# Compiled Binaries
+	unsigned = tempfile.mkstemp()[1]
+
+	with zipfile.ZipFile(unsigned, 'w', compression=zipfile.ZIP_DEFLATED, allowZip64=False) as zipf:
+		# META-INF
+		# update-binary
+		target = os.path.join('META-INF', 'com', 'google', 'android', 'update-binary')
+		print('zip: ' + target)
+		zipf.writestr(target, gen_update_binary())
+		# updater-script
+		source = os.path.join('scripts', 'uninstaller_loader.sh')
+		target = os.path.join('META-INF', 'com', 'google', 'android', 'updater-script')
+		zip_with_msg(zipf, source, target)
+
+		# Binaries
 		for lib_dir, zip_dir in [('arm64-v8a', 'arm64'), ('armeabi-v7a', 'arm'), ('x86', 'x86'), ('x86_64', 'x64')]:
-			source = os.path.join('libs', lib_dir, 'magiskboot')
+			source = os.path.join('out', lib_dir, 'magiskboot')
 			target = os.path.join(zip_dir, 'magiskboot')
 			zip_with_msg(zipf, source, target)
 
@@ -201,37 +320,100 @@ def zip_uninstaller(args):
 		target = 'magisk_uninstaller.sh'
 		zip_with_msg(zipf, source, target)
 
-		source = os.path.join('scripts', 'uninstaller_loader.sh')
-		target = os.path.join('META-INF', 'com', 'google', 'android', 'update-binary')
-		zip_with_msg(zipf, source, target)
+		# Scripts
+		# util_functions.sh
+		source = os.path.join('scripts', 'util_functions.sh')
+		with open(source, 'r') as script:
+			# Remove the stub
+			util_func = script.read().replace(
+				'MAGISK_VERSION_STUB', '')
+			target = os.path.join('util_functions.sh')
+			print('zip: ' + source + ' -> ' + target)
+			zipf.writestr(target, util_func)
 
-		target = os.path.join('META-INF', 'com', 'google', 'android', 'updater-script')
-		print('zip: ' + target)
-		zipf.writestr(target, '#MAGISK\n')
+		# Prebuilts
+		for chromeos in ['futility', 'kernel_data_key.vbprivk', 'kernel.keyblock']:
+			source = os.path.join('chromeos', chromeos)
+			zip_with_msg(zipf, source, source)
 
-	output = 'Magisk-uninstaller-{}.zip'.format(datetime.datetime.now().strftime('%Y%m%d'))
-	sign_adjust_zip('tmp_unsigned.zip', output)
+		# End of zipping
+
+	output = os.path.join('out', 'Magisk-uninstaller-{}.zip'.format(datetime.datetime.now().strftime('%Y%m%d')))
+	sign_adjust_zip(unsigned, output)
+
+def sign_adjust_zip(unsigned, output):
+	signer_name = 'zipsigner-1.0.jar'
+	jarsigner = os.path.join('java', 'crypto', 'build', 'libs', signer_name)
+
+	if os.name != 'nt' and not os.path.exists(os.path.join('ziptools', 'zipadjust')):
+		header('* Building zipadjust')
+		# Compile zipadjust
+		proc = subprocess.run('gcc -o ziptools/zipadjust ziptools/zipadjust_src/*.c -lz', shell=True)
+		if proc.returncode != 0:
+			error('Build zipadjust failed!')
+	if not os.path.exists(jarsigner):
+		header('* Building ' + signer_name)
+		os.chdir('java')
+		proc = subprocess.run('{} crypto:shadowJar'.format(os.path.join('.', 'gradlew')), shell=True)
+		if proc.returncode != 0:
+			error('Build {} failed!'.format(signer_name))
+		os.chdir('..')
+
+	header('* Signing / Adjusting Zip')
+
+	publicKey = os.path.join('ziptools', 'public.certificate.x509.pem')
+	privateKey = os.path.join('ziptools', 'private.key.pk8')
+
+	signed = tempfile.mkstemp()[1]
+
+	# Unsigned->signed
+	proc = subprocess.run(['java', '-jar', jarsigner,
+		publicKey, privateKey, unsigned, signed])
+	if proc.returncode != 0:
+		error('First sign flashable zip failed!')
+
+	adjusted = tempfile.mkstemp()[1]
+
+	# Adjust zip
+	proc = subprocess.run([os.path.join('ziptools', 'zipadjust'), signed, adjusted])
+	if proc.returncode != 0:
+		error('Adjust flashable zip failed!')
+
+	# Adjusted -> output
+	proc = subprocess.run(['java', '-jar', jarsigner,
+		"-m", publicKey, privateKey, adjusted, output])
+	if proc.returncode != 0:
+		error('Second sign flashable zip failed!')
+
+	# Cleanup
+	rm(unsigned)
+	rm(signed)
+	rm(adjusted)
 
 def cleanup(args):
 	if len(args.target) == 0:
-		args.target = ['binary', 'apk', 'zip']
+		args.target = ['binary', 'java', 'zip']
 
 	if 'binary' in args.target:
-		header('* Cleaning Magisk binaries')
+		header('* Cleaning binaries')
 		subprocess.run(os.path.join(os.environ['ANDROID_HOME'], 'ndk-bundle', 'ndk-build') + ' clean', shell=True)
+		for arch in ['arm64-v8a', 'armeabi-v7a', 'x86', 'x86_64']:
+			shutil.rmtree(os.path.join('out', arch), ignore_errors=True)
 
-	if 'apk' in args.target:
-		header('* Cleaning Magisk Manager')
-		os.chdir('MagiskManager')
+	if 'java' in args.target:
+		header('* Cleaning java')
+		os.chdir('java')
 		subprocess.run('{} clean'.format(os.path.join('.', 'gradlew')), shell=True)
 		os.chdir('..')
+		for f in os.listdir('out'):
+			if '.apk' in f:
+				rm(os.path.join('out', f))
 
 	if 'zip' in args.target:
-		header('* Cleaning created zip files')
-		for f in os.listdir('.'):
+		header('* Cleaning zip files')
+		for f in os.listdir('out'):
 			if '.zip' in f:
-				print('rm {}'.format(f))
-				silentremove(f)
+				rm(os.path.join('out', f))
 
 parser = argparse.ArgumentParser(description='Magisk build script')
 parser.add_argument('--release', action='store_true', help='compile Magisk for release')
@@ -250,14 +432,18 @@ binary_parser.set_defaults(func=build_binary)
 apk_parser = subparsers.add_parser('apk', help='build Magisk Manager APK')
 apk_parser.set_defaults(func=build_apk)
 
+snet_parser = subparsers.add_parser('snet', help='build snet extention for Magisk Manager')
+snet_parser.set_defaults(func=build_snet)
+
 zip_parser = subparsers.add_parser('zip', help='zip and sign Magisk into a flashable zip')
 zip_parser.add_argument('versionString')
+zip_parser.add_argument('versionCode', type=int)
 zip_parser.set_defaults(func=zip_main)
 
 uninstaller_parser = subparsers.add_parser('uninstaller', help='create flashable uninstaller')
 uninstaller_parser.set_defaults(func=zip_uninstaller)
 
-clean_parser = subparsers.add_parser('clean', help='clean [target...] Targets: binary apk zip (default: all)')
+clean_parser = subparsers.add_parser('clean', help='clean [target...] targets: binary java zip')
 clean_parser.add_argument('target', nargs='*')
 clean_parser.set_defaults(func=cleanup)
 

docs/README.MD

@@ -0,0 +1,28 @@
+# Magisk Documentations
+(Updated on 2017.9.28) ([Changelog](changelog.md))
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Procedure Diagram](https://cdn.rawgit.com/topjohnwu/Magisk/cc1809688299f1f8b5db494a234850852712c0c9/docs/procedures.html)
+- [Magisk Details](details.md)    
+    - [Boot Stages](details.md#boot-stages)
+    - [Magic Mount Details](details.md#magic-mount-details)
+    - [Simple Mount Details](details.md#simple-mount-details)
+- [Available Applets](applets.md)
+    - [magisk](applets.md#magisk)
+    - [su](applets.md#su)
+    - [resetprop](applets.md#resetprop)
+    - [magiskpolicy](applets.md#magiskpolicy)
+    - [magiskhide](applets.md#magiskhide)
+- [Modules and Repos](module_repo.md)
+    - [Modules and Templates](module_repo.md#magisk-module-format)
+    - [Submit Modules to Repo](module_repo.md#submit-your-module-to-magisk-modules-repo)
+- [Tips and Tricks](tips.md)
+    - [OTA Installation Tips](tips.md#ota-installation-tips)
+    - [Remove Files](tips.md#remove-files)
+    - [Remove Folders](tips.md#remove-folders)
+
+    
+## Introduction
+Magisk is a suite of open source tools for devices running Android version higher than 5.0 Lollipop (API 21). It establishes an environment which covers most Android aftermarket customization needs, such as root, boot scripts, SELinux patches, dm-verity/forceencrypt patches etc.. Furthermore, Magisk also provides a **Systemless Interface** to alter the system (or vendor) arbitrarily while the actual partitions stay completely intact, all of which accomplished by only patching the boot image, and adding some files into `/data`. With its systemless nature along with several other hacks, Magisk can hide modifications from device integrity verifications, one of the main target is to hide from [Google's SafetyNet API](https://developer.android.com/training/safetynet/index.html).

docs/applets.md

@@ -0,0 +1,166 @@
+## Available Applets
+Magisk has a core binary which acts as a multi-call program with many applets. Here is an introduction to all available applets.
+
+### magisk
+The magisk binary itself provides a lot of utility functions when called with the name `magisk`. They are used in both Magisk installation and module installation. The entry point for `init` to invoke magisk's boot procedures are also listed here.
+
+Command help message:
+
+```
+Usage: magisk [applet [arguments]...]
+   or: magisk [options]...
+
+Options:
+   -c                        print current binary version
+   -v                        print running daemon version
+   -V                        print running daemon version code
+   --list                    list all availible applets
+   --install [SOURCE] DIR    symlink all applets to DIR. SOURCE is optional
+   --createimg IMG SIZE      create ext4 image. SIZE is interpreted in MB
+   --imgsize IMG             report ext4 image used/total size
+   --resizeimg IMG SIZE      resize ext4 image. SIZE is interpreted in MB
+   --mountimg IMG PATH       mount IMG to PATH and prints the loop device
+   --umountimg PATH LOOP     unmount PATH and delete LOOP device
+   --[boot stage]            start boot stage service
+   --unlock-blocks           set BLKROSET flag to OFF for all block devices
+
+Supported boot stages:
+   post-fs, post-fs-data, service
+
+Supported applets:
+    su, resetprop, magiskpolicy, supolicy, magiskhide
+```
+
+### su
+The MagiskSU entrypoint. Call `su` to gain a root shell.
+
+Command help message:
+
+```
+Usage: su [options] [--] [-] [LOGIN] [--] [args...]
+
+Options:
+  -c, --command COMMAND         pass COMMAND to the invoked shell
+  -h, --help                    display this help message and exit
+  -, -l, --login                pretend the shell to be a login shell
+  -m, -p,
+  --preserve-environment        do not change environment variables
+  -s, --shell SHELL             use SHELL instead of the default /system/bin/sh
+  -u                            display the multiuser mode and exit
+  -v, --version                 display version number and exit
+  -V                            display version code and exit,
+                                this is used almost exclusively by Superuser.apk
+  -mm, -M,
+  --mount-master                run in the global mount namespace,
+                                use if you need to publicly apply mounts
+```
+
+Note: even though the `-Z, --context` option is not listed above, it actually still exists. However MagiskSU will silently ignore the option since it's not needed anymore. It is still left over because some apps still request root shell with specific contexts as an option.
+
+### resetprop
+An advanced system prop manipulation utility; you can arbitrarily alter system props using this tool. Here's some background knowledge:
+
+> System props are stored in a hybrid trie/binary tree data structure in memory; it was originally designed to only support adding nodes, and no nodes should be removed. Props can be read by many processes (e.g. via the `getprop` command); however, only the `init` process have write access to the property data. `init` provides a `property_service` to accept property update requests, so all property changes are monitored and controlled by `init` Restrictions such as **read-only** props (props that starts with `ro.`), which can only be set once and cannot be changed afterwards, is therefore implemented in `init`.
+
+**resetprop** acts just like `init`: directly access the data structure, bypassing the whole `property_service` part. Doing so, we gain **arbitrary modification** power, including altering read-only props and deleting properties. Delete properties, which was stated *"forbidden"* in the data structure, is implemented through some tricks in the data structure.
+
+One subtle thing to be aware of is that if we change props by directly modifying the data structure, `on property:foo=bar` triggers registered in `*.rc` scripts will not be triggered properly. This may be a good thing or a bad thing, depending on what behavior you expect. I made the default behavior to match the original setprop command, which **WILL** trigger events, but of course I provide a flag (`-n`) to disable it if you need this special behavior.
+
+Command help message:
+
+```
+Usage: resetprop [options] [args...]
+
+Options:
+   -v      show verbose output
+   -n      only modify property in memory
+
+resetprop  NAME VALUE        set property entry NAME with VALUE
+resetprop  --file FILE       load props from FILE
+resetprop  --delete NAME     remove prop entry NAME
+```
+
+### magiskpolicy
+(This tool is aliased to `supolicy` for compatibility)
+
+A tool to patch `sepolicy`. **magiskpolicy** also comes with built-in rules to unleash restrictions to make Magisk work properly. `sepolicy` is a compiled binary containing SELinux rules; we directly patch rules in the binary format since we don't have access to the SELinux policy source (`*.te`) files.
+
+The Magisk daemon itself, the root shell, and all processes spawned from the daemon and root shell are all running in the context `u:r:su:s0`. This context is not only patched to be permissive, but also patched to allow any transition from `u:r:su:s0` to any domain. This was done because Samsung devices do not support permissive out of the box.
+
+The built in patches are split to 3 parts: minimal, medium, and large. The full patch will result in a huge policy file, which might cause the `sepolicy` file unable to fit in `boot.img`.
+
+- The minimal patch is just enough to start Magisk daemon and allow the daemon to further patch the policy during boot time (which is called **live patch**). It is done at installation and directly into `boot.img`. 
+- The medium patch covers most common operations, and is live patched as soon as Magisk daemon is started (blocking boot process).
+- The large patch contains the full patch. Due to the concern of greatly increasing the boot time, it is designed to run in the background until it's joined in the non-blocking late_start bootstage.
+
+What this all means is that **only late_start service mode is guaranteed to run in a fully patched environment**. If any script is not time critical, it is **highly recommended to run those scripts in late_start service mode**.
+
+Command help message:
+
+```
+Usage: magiskpolicy [--options...] [policystatements...]
+
+Options:
+  --live                directly load patched policy to device
+  --minimal             minimal patches, used for boot image patches
+  --load <infile>       load policies from <infile>
+                        (load from live policies if not specified)
+  --save <outfile>      save policies to <outfile>
+
+One policy statement should be treated as one parameter;
+this means a full policy statement should be enclosed in quotes;
+multiple policy statements can be provided in a single command
+
+The statements has a format of "<action> [args...]"
+Use '*' in args to represent every possible match.
+Collections wrapped in curly brackets can also be used as args.
+
+Supported policy statements:
+
+Type 1:
+"<action> source-class target-class permission-class permission"
+Action: allow, deny, auditallow, auditdeny
+
+Type 2:
+"<action> source-class target-class permission-class ioctl range"
+Action: allowxperm, auditallowxperm, dontauditxperm
+
+Type 3:
+"<action> class"
+Action: create, permissive, enforcing
+
+Type 4:
+"attradd class attribute"
+
+Type 5:
+"typetrans source-class target-class permission-class default-class (optional: object-name)"
+
+Notes:
+- typetrans does not support the all match '*' syntax
+- permission-class cannot be collections
+- source-class and target-class can also be attributes
+
+Example: allow { source1 source2 } { target1 target2 } permission-class *
+Will be expanded to:
+
+allow source1 target1 permission-class { all-permissions }
+allow source1 target2 permission-class { all-permissions }
+allow source2 target1 permission-class { all-permissions }
+allow source2 target2 permission-class { all-permissions }
+```
+
+### magiskhide
+This is the CLI to control the state of MagiskHide.
+
+Command help message: 
+
+```
+Usage: magiskhide [--options [arguments...] ]
+
+Options:
+  --enable          Start magiskhide
+  --disable         Stop magiskhide
+  --add PROCESS     Add PROCESS to the hide list
+  --rm PROCESS      Remove PROCESS from the hide list
+  --ls              Print out the current hide list
+```

docs/changelog.md

@@ -0,0 +1,6 @@
+# Changelog
+- 2017.8.16
+    - Initial version for Magisk v13.5
+- 2017.9.28
+    - Update applets info to Magisk v14.1
+    - Add OTA tips

docs/details.md

@@ -0,0 +1,60 @@
+## Boot Stages
+If you are working on complicated projects, you shall need more control to the whole process. Magisk can run scripts in different boot stages, so you can fine tune exactly what you want to do. It's recommended to read this documentation along with the procedure graph.
+
+- post-fs mode
+    - **This stage is BLOCKING. Boot process will NOT continue until everything is done, or 20 seconds has passed**
+    - Happens after most partitions are mounted, except `/data`
+    - Magisk will bind mount files under `/cache/magisk_mount/system` to corresponding paths
+    - It is only **Simple Mount**, which means it will replace existing files, but cannot add/remove files.
+- post-fs-data mode
+    - **This stage is BLOCKING. Boot process will NOT continue until everything is done, or 60 seconds has passed**
+    - Happens after `/data` is ready (including the case when `/data` is encrypted)
+    - Happens before Zygote and system servers are started (which means pretty much everything)
+    - Mirrors will be mounted. These mirrors play a critical role in **Magic Mount**
+    - `/data/magisk.img` will be merged, trimmed, and mounted to `/magisk`
+    - Magisk will run scripts under `/magisk/.core/post-fs-data.d`
+    - Magisk will run scripts: `/magisk/$MODID/post-fs-data.sh` (placed in each module directory)
+    - Magisk will finally **Magisk Mount** module files
+- late_start service mode
+    - **This stage is NON-BLOCKING, it will run in parallel with other processes**
+    - Happens when class late_start is started
+    - Put time consuming but non time critical tasks here. Boot process will be stuck if it took too long to finish your tasks in previous modes
+    - SELinux is guaranteed to be fully patched in this stage; **it is recommended to run most scripts in this stage**, unless your scripts require some time critical operations
+    - Magisk will run scripts under `/magisk/.core/service.d`
+    - Magisk will run scripts: `/magisk/$MODID/service.sh` (placed in each module directory)
+
+## Magic Mount Details
+### Terminology
+- **Item**: A folder, file, or symbolic link
+- **Leaf**: The very end of a directory structure tree, can be either a file or symbolic link
+- **`$MODPATH`**: A variable to represent the path of a module folder
+- **Source item**: An item under `$MODPATH/system`, for example, `$MODPATH/system/build.prop` is a source item
+- **Existing item**: An item under `/system`, for example, `/system/bin/app_process` is an existing item
+- **Target item**: A corresponding item of a source item. For example, the target item of `$MODPATH/system/build.prop` is `/system/build.prop`
+
+Note: A target item does not imply it is an existing item. A target item might not exist in the actual `/system`
+
+### Policies
+- For a source leaf: if its target item is also an existing item, the existing item will be replaced with the source leaf
+- For a source leaf: if its target item is not an existing item, the source leaf will be added to the path of its target item
+- For any existing item that's not a target item, it will stay intact
+
+Above is the rule of thumb. Basically it means that Magic Mount merges the files from `$MODPATH/system` into the real `/system`. A simpler way to understand is to think as it dirty copies the contents from `$MODPATH/system` into `/system`.
+
+However, an addition rule will override the above policies:
+
+- For a source folder containing the file `.replace`, the source folder will be treated as if it is a source leaf. That is, the items within the target folder will be completely discarded, and the target folder will be replaced with the source folder.
+
+Directories containing a file named `.replace` will NOT be merged into the system. It will directly replace the target directory. A simpler way to understand is to think as if it wipes the target folder, and then copies the whole folder to the target path.
+
+### Notes
+- Sometimes, completely replacing a folder is inevitable. For example you want to replace `/system/priv-app/SystemUI` in your stock rom. In stock roms, system apps usually comes with pre-optimized files. If your replacement `SystemUI.apk` is deodexed (which is most likely the case), you would want to replace the whole `/system/priv-app/SystemUI` to make sure the folder only contains the modified `SystemUI.apk` and **NOT** merge with the pre-optimized files.
+- If you are using the [Magisk Module Template](https://github.com/topjohnwu/magisk-module-template), you can create a list of folders you want to replace in the file `config.sh`. The installation scripts will handle the creation of `.replace` files into the listed folders for you.
+- Adding non-existing target items is a relatively expensive operation. Magisk would need to do **MANY** under-the-hood tasks to achieve it. Replacing a whole folder is recommended if viable, it reduces the complexity of the construction of the mounting tree and could speed up the booting time
+
+## Simple Mount Details
+Some files require to be mounted much earlier in the boot process, currently known are bootanimation and some libs (most users won't change them). You can simply place your modified files into the corresponding path under `/cache/magisk_mount`. At boot time, Magisk will **clone all the attributes from the target file**, which includes selinux context, permission mode, owner, group. It'll then bind mount the file to the target. This means you don't need to worry about the metadatas for files placed under `/cache/magisk_mount`: copy the file to the correct place, reboot then you're done!
+
+This mode does not feature the same complex Magic Mount implementation, it will mount a source leaf to an existing target item under `/system`.
+
+For example, you want to replace `/system/media/bootanimation.zip`, copy your new boot animation zip to `/cache/magisk_mount/system/media/bootanimation.zip,` Magisk will mount your files in the next reboot.

docs/module_repo.md

@@ -0,0 +1,76 @@
+# Magisk Modules and Online Repo
+## Magisk Module Format
+The Magisk module is a folder under `magisk`, which has a structure as described below:
+
+```
+magisk
+├── .
+├── .
+├── a_module                <--- The ID of the module, should match with module.prop
+│   ├── auto_mount          <--- If this file exists, auto mount is enabled
+│   ├── disable             <--- If this file exists, the module is disabled
+│   ├── module.prop         <--- This files stores the indentity and properties of the module
+│   ├── post-fs-data.sh     <--- This script will be executed in post-fs-data
+│   ├── remove              <--- If this file exists, the module will be removed next reboot
+│   ├── service.sh          <--- This script will be executed in late_start service
+│   ├── system.prop         <--- This file will be loaded as system props
+│   ├── system              <--- If auto mount is enabled, Magisk will "Magic Mount" this folder
+│   │   ├── app
+│   │   ├── .
+│   │   └── .
+│   ├── vendor              <--- Auto generated. A symlink to $MODID/system/vendor
+│   ├── .                   <--- Any other files/folders are allowed
+│   └── .		
+├── another_module
+│   ├── .
+│   └── .
+├── .
+├── .
+```
+
+## Magisk Module Template
+The **Magisk Module Template** is hosted **[here](https://github.com/topjohnwu/magisk-module-template)**.
+
+It is a template to create a flashable zip to install Magisk Modules. It is created to be simple to use so that anyone can create their own modules easily. The template itself contains minimal scripting for installation; most of the functions are located externally in [util_functions.sh](https://github.com/topjohnwu/Magisk/blob/master/scripts/util_functions.sh), which will be installed along with Magisk, and can be upgraded through a Magisk upgrade without the need of a template update.
+
+The template should meet most modules' needs. Add files into `system`, which will be cloned into `/system` by Magisk after installing the module, and in addition to module files, `system.prop`, `post-fs-data.sh`, `service.sh` are also installable through this template.
+
+Here are some files you would want to know:
+
+- `config.sh`: A simple script used as a configuration file for the actual installation file to correctly install your module. It is the place you can select which features your module needs/disables.
+- `module.prop`: This file contains your module's indentity and properties, including name and versions etc.. This file will be used to identify your module on an actual device and in the [Magisk Modules Repo](https://github.com/Magisk-Modules-Repo)
+- `common/*`: These files will be installed to the module with the correspond role
+- `META-INF/com/google/android/update-binary`: The actual installation script. Modify this file for advanced custom behavior
+
+## Create a Magisk Module With The Template
+1. Clone / download [this repo](https://github.com/topjohnwu/magisk-module-template)
+1. Open `config.sh` and carefully read the fully documented file. Follow the instructions within the script
+1. You should at least have `config.sh` and `module.prop` modified
+1. Directly zip all files; the result zip file is a flashable zip that can be used in both Magisk Manager and custom recoveries
+1. Please check [**Notes**](#notes) for several precautions
+
+## Submit Your Module to Magisk Modules Repo
+If you want to share your module with others, you can submit your modules to [Magisk Modules Repo](https://github.com/Magisk-Modules-Repo). You would need some basic `git` knowledge here.
+
+1. Create a module as stated above, and test if it works properly
+1. Fork [this repo](https://github.com/topjohnwu/magisk-module-template) to your account
+1. Commit and push your changes to your forked repo
+1. Open an issue in [topjohnwu/Magisk_Repo_Central](https://github.com/topjohnwu/Magisk_Repo_Central/issues/new) with your repo link
+1. I will review your module, and once accepted, your repo should be cloned into [Magisk-Modules-Repo](https://github.com/Magisk-Modules-Repo)
+1. You should receive an email to become the collaborator so you can edit the repo in the future.
+
+#### Once your module is live on the Modules Repo, the description of your repo should be the ID of your module. Please do NOT change the description, repeat, do NOT change the description.
+
+![repo_description.png](images/repo_description.png)
+
+## Notes
+- The Module Template depends on external scripts, be aware of the minimal required Magisk version of the template.
+- **Windows users please check here!!** The line endings of all text files should be in the **Unix format**. Please use advanced text editors like Sublime, Atom, Notepad++ etc. to edit **ALL** text files, **NEVER** use Windows Notepad.
+- In `module.prop`, `version` can be an arbitrary string, so any fancy version name (e.g. ultra-beta-v1.1.1.1) is allowed. However, `versionCode` **MUST** be an integer. The value is used for version comparison.
+- Make sure your module ID **does not contain any spaces**.
+
+## Notes For Repo Developers
+
+- Magisk Manager monitors all repo's `master` branch. Any changes to the branch `master` will be reflected to all users immediately. If you are working on an update for a module, please work on another branch, make sure it works, then finally merge the changes back to `master`.
+- Once you finished upgrading your repo, increase at least the `versionCode` in `module.prop`. Magisk Manager uses this value to compare with the local installed module to determine whether an update is availible.
+- The description of your repo should be the same as your module ID. If you changed your description, Magisk Manager will fail to identify your repo, and cannot relate installed module to the online repo together.

docs/tips.md

@@ -0,0 +1,53 @@
+# Tips and Tricks
+
+## OTA Installation Tips
+Magisk do modifications systemless-ly, which means applying official OTAs is much simpler. Here I provide a few tutorials for several different kind of devices to apply OTAs and preserve Magisk after the installation if possible.
+
+**This tutorial is only for Magisk v14.1+**
+
+**NOTE: In order to apply OTAs, you HAVE to make sure you haven't modified `/system` (and `/vendor` if available) in anyway, even remounting the partition to rw will tamper block verification!!**
+
+#### Prerequisites
+1. Please disable *Automatic system updates* in developer options, so it won't install OTAs without your acknowledgement.  
+    <img src="images/disable_auto_ota.png" width="250">
+1. When an OTA is available, please go to Magisk Manager → Uninstall → Restore Stock Boot. **Do not reboot immediately or you will have Magisk uninstalled.** This will restore your boot back to 100% untouched stock boot image in order to pass boot verification. **This step is required before doing any of the following steps written below!**  
+    <img src="images/restore_boot.png" width="250">
+
+#### Devices with A/B Partitions
+(Includes Pixel family)
+
+Due to the fact that these devices have two separate partitions and the OTA installation happens live when the system is still running, these devices have the best support: the out-of-the-box OTA installation works seamlessly and Magisk will be preserved after the installation.
+
+1. After restoring stock boot image, apply OTAs as you normally would (Settings → System → System Updates)
+1. Once the installation passed step 1 and starting step 2, go to Magisk Manager → Install → Install to Second Slot. This will install Magisk into the second boot image slot, which is the updated slot.  
+    <img src="images/ota_step2.png" width="250"> <img src="images/install_second_slot.png" width="250">
+1. Let the OTA finish its job. After a reboot, the bootloader will switch to the updated system. Magisk should still be installed since we already patched the new boot image.
+
+#### Devices with FlashFire Support
+(Includes Pixel family, Nexus family, Samsung devices)  
+(If you are using a device with A/B partitions, I **strongly** recommend you to use the method stated above since it uses the stock OTA installation mechanism and will always work under any circumstances)
+
+The [FlashFire](https://play.google.com/store/apps/details?id=eu.chainfire.flash) app developed by Chainfire is a great app to apply OTAs and preserve root at the same time. However, whether it supports your device/system combination depends on the application itself, and support may also change in the future. If you face any issues, please directly [report to Chainfire](https://forum.xda-developers.com/general/paid-software/flashfire-t3075433).  
+
+1. After restoring the stock boot image, download the OTA (Settings → System → System Updates), **do not press reboot to install.**
+1. Open FlashFire, it should detect your OTA zip. Select OK in the popup dialog to let it do its setup.
+1. Please use the options shown in the screenshot below. The key point is to disable EverRoot (or it will install SuperSU), and add a new action to flash Magisk zip **after** the OTA update.zip (the update.zip is auto generated in the previous step).  
+    <img src="images/flashfire.png" width="250">
+1. Press the big **Flash** button, after a few minutes it should reboot updated with Magisk installed.
+
+#### Other Devices - General Case
+Unfortunately, there are no real good ways to apply OTAs on all devices. Also, the tutorial provided below will not preserve Magisk - you will have to manually re-root your device after the upgrade, and this will require PC access. Here I share my personal experience with my daily driver - HTC U11.
+
+1. To properly install OTAs, you should have your stock recovery installed on your device. If you have custom recovery installed, you can restore it from your previous backup, or dumps found online, or factory images provided by OEMs.  
+If you decide to start by installing Magisk without touching your recovery partition, you have a few choices, either way you will end up with a Magisk rooted device, but recovery remain stock untouched:
+    - If supported, use `fastboot boot <recovery_img>` to boot the custom recovery and install Magisk. 
+    - If you have a copy of your stock boot image dump, install Magisk by patching boot image via Magisk Manager, and manually flash it through download mode / fastboot mode / Odin
+1. Once your device have stock recovery and stock boot image restored, download the OTA. Optionally, once you downloaded the OTA update zip, you can find a way to copy the zip out since you are still rooted. Personally I will extract the stock boot image and recovery image from the OTA zip for future usage (to patch via Magisk Manager or restore stock recovery etc.)
+1. Apply and reboot your device. This will use the official stock OTA installation mechanism of your device to upgrade your system.
+1. Once it's done you will be left with an upgraded, 100% stock, un-rooted device. You will have to manually flash Magisk back. Consider using the methods stated in step 1. to flash Magisk without touching the recovery partition if you want to receive stock OTAs frequently.
+
+## Remove Files
+How to efficiently remove a file systemless-ly? To actually make the file **disappear** is complicated (possible, not worth the effort). **Replacing it with a dummy file should be good enough**! Create an empty file with the same name and place it in the same path within a module, it shall replace your target file with a dummy file.
+
+## Remove Folders
+Same as mentioned above, actually making the folder to **disappear** is not worth the effort. **Replacing it with an empty folder should be good enough**! A handy trick for module developers using [Magisk Module Template](https://github.com/topjohnwu/magisk-module-template) is to add the folder you want to remove into the `REPLACE` list within `config.sh`. If your module doesn't provide a correspond folder, it will create an empty folder, and automatically add `.replace` into the empty folder so the dummy folder will properly replace the one in `/system`.

jni/Android.mk

@@ -1,65 +1,133 @@
 LOCAL_PATH := $(call my-dir)
 
+# Some handy paths
+EXT_PATH := jni/external
+SE_PATH := $(EXT_PATH)/selinux
+LIBSELINUX := $(SE_PATH)/libselinux/include
+LIBSEPOL := $(SE_PATH)/libsepol/include $(SE_PATH)/libsepol/cil/include
+LIBLZMA := $(EXT_PATH)/xz/src/liblzma/api
+LIBLZ4 := $(EXT_PATH)/lz4/lib
+LIBBZ2 := $(EXT_PATH)/bzip2
+LIBFDT := $(EXT_PATH)/dtc/libfdt
+
+########################
+# Binaries
+########################
+
+ifdef PRECOMPILE
+
+# magisk main binary
 include $(CLEAR_VARS)
 LOCAL_MODULE := magisk
-LOCAL_STATIC_LIBRARIES := libsepol
 LOCAL_SHARED_LIBRARIES := libsqlite libselinux
 
 LOCAL_C_INCLUDES := \
-	$(LOCAL_PATH)/utils \
-	$(LOCAL_PATH)/daemon \
-	$(LOCAL_PATH)/resetprop \
-	$(LOCAL_PATH)/magiskpolicy \
-	$(LOCAL_PATH)/selinux/libselinux/include \
-	$(LOCAL_PATH)/selinux/libsepol/include \
-	$(LOCAL_PATH)/sqlite3
+	jni/include \
+	jni/external \
+	$(LIBSELINUX)
 
 LOCAL_SRC_FILES := \
-	main.c \
+	core/magisk.c \
+	core/daemon.c \
+	core/log_monitor.c \
+	core/bootstages.c \
 	utils/misc.c \
 	utils/vector.c \
 	utils/xwrap.c \
 	utils/list.c \
-	daemon/daemon.c \
-	daemon/socket_trans.c \
-	daemon/log_monitor.c \
-	daemon/bootstages.c \
+	utils/img.c \
+	utils/file.c \
 	magiskhide/magiskhide.c \
-	magiskhide/hide_daemon.c \
 	magiskhide/proc_monitor.c \
-	magiskhide/pre_process.c \
-	magiskhide/list_manager.c \
-	magiskpolicy/magiskpolicy.c \
-	magiskpolicy/rules.c \
-	magiskpolicy/sepolicy.c \
-	magiskpolicy/api.c \
+	magiskhide/hide_utils.c \
 	resetprop/resetprop.cpp \
 	resetprop/system_properties.cpp \
 	su/su.c \
 	su/activity.c \
 	su/db.c \
-	su/misc.c \
 	su/pts.c \
 	su/su_daemon.c \
 	su/su_socket.c
 
-LOCAL_CFLAGS := -Wno-implicit-exception-spec-mismatch
+LOCAL_CFLAGS := -DIS_DAEMON
 LOCAL_LDLIBS := -llog
-
 include $(BUILD_EXECUTABLE)
 
-# Libraries
-include jni/selinux/libselinux/Android.mk
-include jni/selinux/libsepol/Android.mk
-include jni/sqlite3/Android.mk
+# precompile
+else
 
-#####################################################################
-# In order to build separate binaries, please comment out everything 
-# starting from line 3 (including the 3 lines for libraries)
-# Then, uncomment the line you want below
-#####################################################################
-# include jni/resetprop/Android.mk
-# include jni/magiskpolicy/Android.mk
+# magiskinit
+include $(CLEAR_VARS)
+LOCAL_MODULE := magiskinit
+LOCAL_STATIC_LIBRARIES := libsepol liblzma
+LOCAL_C_INCLUDES := \
+	jni/include \
+	out/$(TARGET_ARCH_ABI) \
+	$(LIBSEPOL) \
+	$(LIBLZMA)
 
-# Build magiskboot
-include jni/magiskboot/Android.mk
+LOCAL_SRC_FILES := \
+	core/magiskinit.c \
+	utils/vector.c \
+	utils/file.c \
+	utils/xwrap.c \
+	magiskpolicy/api.c \
+	magiskpolicy/magiskpolicy.c \
+	magiskpolicy/rules.c \
+	magiskpolicy/sepolicy.c
+
+LOCAL_CFLAGS := -DNO_SELINUX
+LOCAL_LDFLAGS := -static
+include $(BUILD_EXECUTABLE)
+
+# magiskboot
+include $(CLEAR_VARS)
+LOCAL_MODULE := magiskboot
+LOCAL_STATIC_LIBRARIES := liblzma liblz4 libbz2 libfdt
+LOCAL_C_INCLUDES := \
+	jni/include \
+	$(LIBLZMA) \
+	$(LIBLZ4) \
+	$(LIBBZ2) \
+	$(LIBFDT)
+
+LOCAL_SRC_FILES := \
+	magiskboot/main.c \
+	magiskboot/bootimg.c \
+	magiskboot/hexpatch.c \
+	magiskboot/compress.c \
+	magiskboot/cpio.c \
+	magiskboot/sha1.c \
+	magiskboot/types.c \
+	magiskboot/dtb.c \
+	utils/xwrap.c \
+	utils/file.c \
+	utils/vector.c
+
+LOCAL_CFLAGS := -DNO_SELINUX
+LOCAL_LDLIBS := -lz
+include $(BUILD_EXECUTABLE)
+
+# 32-bit static binaries
+ifneq ($(TARGET_ARCH_ABI), x86_64)
+ifneq ($(TARGET_ARCH_ABI), arm64-v8a)
+# b64xz
+include $(CLEAR_VARS)
+LOCAL_MODULE := b64xz
+LOCAL_STATIC_LIBRARIES := liblzma
+LOCAL_C_INCLUDES := $(LIBLZMA)
+LOCAL_SRC_FILES := b64xz.c
+LOCAL_LDFLAGS := -static
+include $(BUILD_EXECUTABLE)
+# Busybox
+include jni/external/busybox/Android.mk
+endif
+endif
+
+# Precompile
+endif
+
+########################
+# Externals
+########################
+include jni/external/Android.mk

jni/Application.mk

@@ -1,4 +1,4 @@
 APP_ABI := x86 x86_64 armeabi-v7a arm64-v8a
 APP_PLATFORM := android-21
-APP_UNIFIED_HEADERS := true
-APP_CPPFLAGS += -std=c++11
+APP_CFLAGS := $(MAGISK_FLAGS) -std=gnu99
+APP_CPPFLAGS := -std=c++11

jni/b64xz.c

@@ -0,0 +1,83 @@
+/* b64xz.c - Base64-XZ Extractor
+ *
+ * This program expects data from stdin. The data should be compressed with xz and
+ * then encoded into base64 format. What b64xz does is basically the reverse of the
+ * mentioned process: decode base64 to uint8_ts, decompress xz, then dump to stdout
+ *
+ * The compiled binary will be hex-dumped into update-binary
+ * Busybox will be xz-compressed, base64 encoded and dumped into update-binary
+ * This program is to recover busybox for Magisk installation environment
+ *
+ * I intentionally removed stdio. This will result in a smaller binary size because
+ * all I/O are handled by system calls (read/write) instead of libc wrappers
+ */
+
+#include <unistd.h>
+#include <lzma.h>
+
+#define BUFSIZE 8192
+
+static const char trans_tbl[] =
+		"|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";
+
+static void decodeblock(uint8_t* in, uint8_t* out) {
+	out[0] = (uint8_t)(in[0] << 2 | in[1] >> 4);
+	out[1] = (uint8_t)(in[1] << 4 | in[2] >> 2);
+	out[2] = (uint8_t)(((in[2] << 6) & 0xc0) | in[3]);
+}
+
+static int unxz(lzma_stream *strm, void *buf, size_t size) {
+	lzma_ret ret = 0;
+	uint8_t out[BUFSIZE];
+	strm->next_in = buf;
+	strm->avail_in = size;
+	do {
+		strm->next_out = out;
+		strm->avail_out = sizeof(out);
+		ret = lzma_code(strm, LZMA_RUN);
+		write(STDOUT_FILENO, out, sizeof(out) - strm->avail_out);
+	} while (strm->avail_out == 0 && ret == LZMA_OK);
+
+	if (ret != LZMA_OK && ret != LZMA_STREAM_END)
+		write(STDERR_FILENO, "LZMA error!\n", 13);
+	return ret;
+}
+
+int main(int argc, char const* argv[]) {
+	if (argc > 1)
+		return 0;
+
+	uint8_t in[4], buf[BUFSIZE];
+	int len = 0, pos = 0;
+	char c;
+
+	// Setup lzma stream
+	lzma_stream strm = LZMA_STREAM_INIT;
+	if (lzma_auto_decoder(&strm, UINT64_MAX, 0) != LZMA_OK) {
+		write(STDERR_FILENO, "Unable to init lzma stream\n", 28);
+		return 1;
+	}
+
+	while (read(STDIN_FILENO, &c, sizeof(c)) == 1) {
+		c = ((c < 43 || c > 122) ? -1 : (trans_tbl[c - 43] == '$' ? -1 : trans_tbl[c - 43] - 62));
+		if (c >= 0)
+			in[len++] = c;
+		if (len < 4)
+			continue;
+		len = 0;
+		decodeblock(in, buf + pos);
+		pos += 3;
+		if (pos > sizeof(buf) - 3) {
+			// Buffer is full, unxz
+			if (unxz(&strm, buf, pos))
+				return 1;
+			pos = 0;
+		}
+	}
+	if (pos) {
+		if (unxz(&strm, buf, pos))
+			return 1;
+	}
+	lzma_end(&strm);
+	return 0;
+}

jni/core/bootstages.c

@@ -0,0 +1,791 @@
+/* bootstages.c - Core bootstage operations
+ *
+ * All bootstage operations, including simple mount in post-fs,
+ * magisk mount in post-fs-data, various image handling, script
+ * execution, load modules, install Magisk Manager etc.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <dirent.h>
+#include <linux/loop.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h>
+#include <sys/wait.h>
+#include <selinux/selinux.h>
+
+#include "magisk.h"
+#include "utils.h"
+#include "daemon.h"
+#include "resetprop.h"
+
+static char *buf, *buf2;
+static struct vector module_list;
+static int seperate_vendor = 0;
+
+extern char **environ;
+
+/******************
+ * Node structure *
+ ******************/
+
+// Precedence: MODULE > SKEL > INTER > DUMMY
+#define IS_DUMMY   0x01    /* mount from mirror */
+#define IS_INTER   0x02    /* intermediate node */
+#define IS_SKEL    0x04    /* mount from skeleton */
+#define IS_MODULE  0x08    /* mount from module */
+
+#define IS_DIR(n)  (n->type == DT_DIR)
+#define IS_LNK(n)  (n->type == DT_LNK)
+#define IS_REG(n)  (n->type == DT_REG)
+
+struct node_entry {
+	const char *module;    /* Only used when status & IS_MODULE */
+	char *name;
+	uint8_t type;
+	uint8_t status;
+	struct node_entry *parent;
+	struct vector *children;
+};
+
+static void concat_path(struct node_entry *node) {
+	if (node->parent)
+		concat_path(node->parent);
+	int len = strlen(buf);
+	buf[len] = '/';
+	strcpy(buf + len + 1, node->name);
+}
+
+static char *get_full_path(struct node_entry *node) {
+	buf[0] = '\0';
+	concat_path(node);
+	return strdup(buf);
+}
+
+// Free the node
+static void destroy_node(struct node_entry *node) {
+	free(node->name);
+	vec_destroy(node->children);
+	free(node->children);
+	free(node);
+}
+
+// Free the node and all children recursively
+static void destroy_subtree(struct node_entry *node) {
+	// Never free parent, since it shall be freed by themselves
+	struct node_entry *e;
+	vec_for_each(node->children, e) {
+		destroy_subtree(e);
+	}
+	destroy_node(node);
+}
+
+// Return the child
+static struct node_entry *insert_child(struct node_entry *p, struct node_entry *c) {
+	c->parent = p;
+	if (p->children == NULL) {
+		p->children = xmalloc(sizeof(struct vector));
+		vec_init(p->children);
+	}
+	struct node_entry *e;
+	vec_for_each(p->children, e) {
+		if (strcmp(e->name, c->name) == 0) {
+			// Exist duplicate
+			if (c->status > e->status) {
+				// Precedence is higher, replace with new node
+				destroy_subtree(e);
+				vec_cur(p->children) = c;
+				return c;
+			} else {
+				// Free the new entry, return old
+				destroy_node(c);
+				return e;
+			}
+		}
+	}
+	// New entry, push back
+	vec_push_back(p->children, c);
+	return c;
+}
+
+/***********
+ * setenvs *
+ ***********/
+
+static void bb_setenv(struct vector *v) {
+	for (int i = 0; environ[i]; ++i) {
+		if (strncmp(environ[i], "PATH=", 5) == 0) {
+			snprintf(buf, PATH_MAX, "PATH=%s:%s", BBPATH, strchr(environ[i], '=') + 1);
+			vec_push_back(v, strdup(buf));
+		} else {
+			vec_push_back(v, strdup(environ[i]));
+		}
+	}
+	vec_push_back(v, NULL);
+}
+
+static void pm_setenv(struct vector *v) {
+	for (int i = 0; environ[i]; ++i) {
+		if (strncmp(environ[i], "CLASSPATH=", 10) != 0)
+			vec_push_back(v, strdup(environ[i]));
+	}
+	vec_push_back(v, strdup("CLASSPATH=/system/framework/pm.jar"));
+	vec_push_back(v, NULL);
+}
+
+/***********
+ * Scripts *
+ ***********/
+
+static void exec_common_script(const char* stage) {
+	DIR *dir;
+	struct dirent *entry;
+	snprintf(buf, PATH_MAX, "%s/%s.d", COREDIR, stage);
+
+	if (!(dir = xopendir(buf)))
+		return;
+
+	while ((entry = xreaddir(dir))) {
+		if (entry->d_type == DT_REG) {
+			snprintf(buf2, PATH_MAX, "%s/%s", buf, entry->d_name);
+			if (access(buf2, X_OK) == -1)
+				continue;
+			LOGI("%s.d: exec [%s]\n", stage, entry->d_name);
+			int pid = exec_command(0, NULL, bb_setenv, "sh", buf2, NULL);
+			if (pid != -1)
+				waitpid(pid, NULL, 0);
+		}
+	}
+
+	closedir(dir);
+}
+
+static void exec_module_script(const char* stage) {
+	char *module;
+	vec_for_each(&module_list, module) {
+		snprintf(buf2, PATH_MAX, "%s/%s/%s.sh", MOUNTPOINT, module, stage);
+		snprintf(buf, PATH_MAX, "%s/%s/disable", MOUNTPOINT, module);
+		if (access(buf2, F_OK) == -1 || access(buf, F_OK) == 0)
+			continue;
+		LOGI("%s: exec [%s.sh]\n", module, stage);
+		int pid = exec_command(0, NULL, bb_setenv, "sh", buf2, NULL);
+		if (pid != -1)
+			waitpid(pid, NULL, 0);
+	}
+
+}
+
+/***************
+ * Magic Mount *
+ ***************/
+
+static void construct_tree(const char *module, struct node_entry *parent) {
+	DIR *dir;
+	struct dirent *entry;
+	struct node_entry *node;
+
+	char *parent_path = get_full_path(parent);
+	snprintf(buf, PATH_MAX, "%s/%s%s", MOUNTPOINT, module, parent_path);
+
+	if (!(dir = xopendir(buf)))
+		goto cleanup;
+
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		// Create new node
+		node = xcalloc(sizeof(*node), 1);
+		node->module = module;
+		node->name = strdup(entry->d_name);
+		node->type = entry->d_type;
+		snprintf(buf, PATH_MAX, "%s/%s", parent_path, node->name);
+
+		/*
+		 * Clone the parent in the following condition:
+		 * 1. File in module is a symlink
+		 * 2. Target file do not exist
+		 * 3. Target file is a symlink, but not /system/vendor
+		 */
+		int clone = 0;
+		if (IS_LNK(node) || access(buf, F_OK) == -1) {
+			clone = 1;
+		} else if (parent->parent != NULL || strcmp(node->name, "vendor") != 0) {
+			struct stat s;
+			xstat(buf, &s);
+			if (S_ISLNK(s.st_mode))
+				clone = 1;
+		}
+
+		if (clone) {
+			// Mark the parent folder as a skeleton
+			parent->status |= IS_SKEL;  /* This will not overwrite if parent is module */
+			node->status = IS_MODULE;
+		} else if (IS_DIR(node)) {
+			// Check if marked as replace
+			snprintf(buf2, PATH_MAX, "%s/%s%s/.replace", MOUNTPOINT, module, buf);
+			if (access(buf2, F_OK) == 0) {
+				// Replace everything, mark as leaf
+				node->status = IS_MODULE;
+			} else {
+				// This will be an intermediate node
+				node->status = IS_INTER;
+			}
+		} else if (IS_REG(node)) {
+			// This is a leaf, mark as target
+			node->status = IS_MODULE;
+		}
+		node = insert_child(parent, node);
+		if (node->status & (IS_SKEL | IS_INTER)) {
+			// Intermediate folder, travel deeper
+			construct_tree(module, node);
+		}
+	}
+
+	closedir(dir);
+
+cleanup:
+	free(parent_path);
+}
+
+static void clone_skeleton(struct node_entry *node) {
+	DIR *dir;
+	struct dirent *entry;
+	struct node_entry *dummy, *child;
+
+	// Clone the structure
+	char *full_path = get_full_path(node);
+	snprintf(buf, PATH_MAX, "%s%s", MIRRDIR, full_path);
+	if (!(dir = xopendir(buf)))
+		goto cleanup;
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		// Create dummy node
+		dummy = xcalloc(sizeof(*dummy), 1);
+		dummy->name = strdup(entry->d_name);
+		dummy->type = entry->d_type;
+		dummy->status = IS_DUMMY;
+		insert_child(node, dummy);
+	}
+	closedir(dir);
+
+	if (node->status & IS_SKEL) {
+		struct stat s;
+		char *con;
+		xstat(full_path, &s);
+		getfilecon(full_path, &con);
+		LOGI("tmpfs: %s\n", full_path);
+		xmount("tmpfs", full_path, "tmpfs", 0, NULL);
+		chmod(full_path, s.st_mode & 0777);
+		chown(full_path, s.st_uid, s.st_gid);
+		setfilecon(full_path, con);
+		free(con);
+	}
+
+	vec_for_each(node->children, child) {
+		snprintf(buf, PATH_MAX, "%s/%s", full_path, child->name);
+
+		// Create the dummy file/directory
+		if (IS_DIR(child))
+			xmkdir(buf, 0755);
+		else if (IS_REG(child))
+			close(creat(buf, 0644));
+		// Links will be handled later
+
+		if (child->parent->parent == NULL && strcmp(child->name, "vendor") == 0) {
+			if (IS_LNK(child)) {
+				cp_afc(MIRRDIR "/system/vendor", "/system/vendor");
+				LOGI("cplink: %s -> %s\n", MIRRDIR "/system/vendor", "/system/vendor");
+			}
+			// Skip
+			continue;
+		} else if (child->status & IS_MODULE) {
+			// Mount from module file to dummy file
+			snprintf(buf2, PATH_MAX, "%s/%s%s/%s", MOUNTPOINT, child->module, full_path, child->name);
+		} else if (child->status & (IS_SKEL | IS_INTER)) {
+			// It's an intermediate folder, recursive clone
+			clone_skeleton(child);
+			continue;
+		} else if (child->status & IS_DUMMY) {
+			// Mount from mirror to dummy file
+			snprintf(buf2, PATH_MAX, "%s%s/%s", MIRRDIR, full_path, child->name);
+		}
+
+		if (IS_LNK(child)) {
+			// Copy symlinks directly
+			cp_afc(buf2, buf);
+			#ifdef MAGISK_DEBUG
+				LOGI("cplink: %s -> %s\n",buf2, buf);
+			#else
+				LOGI("cplink: %s\n", buf);
+			#endif
+		} else {
+			snprintf(buf, PATH_MAX, "%s/%s", full_path, child->name);
+			bind_mount(buf2, buf);
+		}
+	}
+
+cleanup:
+	free(full_path);
+}
+
+static void magic_mount(struct node_entry *node) {
+	char *real_path;
+	struct node_entry *child;
+
+	if (node->status & IS_MODULE) {
+		// The real deal, mount module item
+		real_path = get_full_path(node);
+		snprintf(buf, PATH_MAX, "%s/%s%s", MOUNTPOINT, node->module, real_path);
+		bind_mount(buf, real_path);
+		free(real_path);
+	} else if (node->status & IS_SKEL) {
+		// The node is labeled to be cloned with skeleton, lets do it
+		clone_skeleton(node);
+	} else if (node->status & IS_INTER) {
+		// It's an intermediate node, travel deeper
+		vec_for_each(node->children, child)
+			magic_mount(child);
+	}
+	// The only thing goes here should be vendor placeholder
+	// There should be no dummies, so don't need to handle it here
+}
+
+/****************
+ * Simple Mount *
+ ****************/
+
+static void simple_mount(const char *path) {
+	DIR *dir;
+	struct dirent *entry;
+
+	snprintf(buf, PATH_MAX, "%s%s", CACHEMOUNT, path);
+	if (!(dir = opendir(buf)))
+		return;
+
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		// Target file path
+		snprintf(buf2, PATH_MAX, "%s/%s", path, entry->d_name);
+		// Only mount existing file
+		if (access(buf2, F_OK) == -1)
+			continue;
+		if (entry->d_type == DT_DIR) {
+			char *new_path = strdup(buf2);
+			simple_mount(new_path);
+			free(new_path);
+		} else if (entry->d_type == DT_REG) {
+			// Actual file path
+			snprintf(buf, PATH_MAX, "%s%s", CACHEMOUNT, buf2);
+			// Clone all attributes
+			clone_attr(buf2, buf);
+			// Finally, mount the file
+			bind_mount(buf, buf2);
+		}
+	}
+
+	closedir(dir);
+}
+
+/*****************
+ * Miscellaneous *
+ *****************/
+
+// A one time setup
+static void daemon_init() {
+	LOGI("* Creating /sbin overlay");
+	DIR *dir;
+	struct dirent *entry;
+	int root, sbin;
+	// Setup links under /sbin
+	xmount(NULL, "/", NULL, MS_REMOUNT, NULL);
+	xmkdir("/root", 0755);
+	chmod("/root", 0755);
+	root = xopen("/root", O_RDONLY | O_CLOEXEC);
+	sbin = xopen("/sbin", O_RDONLY | O_CLOEXEC);
+	dir = xfdopendir(sbin);
+	while((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
+		linkat(sbin, entry->d_name, root, entry->d_name, 0);
+		if (strcmp(entry->d_name, "magisk") == 0)
+			unlinkat(sbin, entry->d_name, 0);
+	}
+	close(sbin);
+	xmount("tmpfs", "/sbin", "tmpfs", 0, NULL);
+	sbin = xopen("/sbin", O_RDONLY | O_CLOEXEC);
+	fchmod(sbin, 0755);
+	fsetfilecon(sbin, "u:object_r:rootfs:s0");
+	dir = xfdopendir(root);
+	while((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
+		snprintf(buf, PATH_MAX, "/root/%s", entry->d_name);
+		snprintf(buf2, PATH_MAX, "/sbin/%s", entry->d_name);
+		xsymlink(buf, buf2);
+	}
+	for (int i = 0; applet[i]; ++i) {
+		snprintf(buf2, PATH_MAX, "/sbin/%s", applet[i]);
+		xsymlink("/root/magisk", buf2);
+	}
+	xsymlink(MOUNTPOINT, FAKEPOINT);
+	close(root);
+	close(sbin);
+	xmount(NULL, "/", NULL, MS_REMOUNT | MS_RDONLY, NULL);
+
+	LOGI("* Mounting mirrors");
+	struct vector mounts;
+	vec_init(&mounts);
+	file_to_vector("/proc/mounts", &mounts);
+	char *line;
+	int skip_initramfs = 0;
+	// Check whether skip_initramfs device
+	vec_for_each(&mounts, line) {
+		if (strstr(line, " /system_root ")) {
+			xmkdir_p(MIRRDIR "/system", 0755);
+			bind_mount("/system_root/system", MIRRDIR "/system");
+			skip_initramfs = 1;
+			break;
+		}
+	}
+	vec_for_each(&mounts, line) {
+		if (!skip_initramfs && strstr(line, " /system ")) {
+			sscanf(line, "%s", buf);
+			xmkdir_p(MIRRDIR "/system", 0755);
+			xmount(buf, MIRRDIR "/system", "ext4", MS_RDONLY, NULL);
+			#ifdef MAGISK_DEBUG
+				LOGI("mount: %s -> %s\n", buf, MIRRDIR "/system");
+			#else
+				LOGI("mount: %s\n", MIRRDIR "/system");
+			#endif
+		} else if (strstr(line, " /vendor ")) {
+			seperate_vendor = 1;
+			sscanf(line, "%s", buf);
+			xmkdir_p(MIRRDIR "/vendor", 0755);
+			xmount(buf, MIRRDIR "/vendor", "ext4", MS_RDONLY, NULL);
+			#ifdef MAGISK_DEBUG
+				LOGI("mount: %s -> %s\n", buf, MIRRDIR "/vendor");
+			#else
+				LOGI("mount: %s\n", MIRRDIR "/vendor");
+			#endif
+		}
+		free(line);
+	}
+	vec_destroy(&mounts);
+	if (!seperate_vendor) {
+		xsymlink(MIRRDIR "/system/vendor", MIRRDIR "/vendor");
+		#ifdef MAGISK_DEBUG
+			LOGI("link: %s -> %s\n", MIRRDIR "/system/vendor", MIRRDIR "/vendor");
+		#else
+			LOGI("link: %s\n", MIRRDIR "/vendor");
+		#endif
+	}
+	xmkdir_p(MIRRDIR "/bin", 0755);
+	bind_mount(DATABIN, MIRRDIR "/bin");
+
+	LOGI("* Setting up internal busybox");
+	xmkdir_p(BBPATH, 0755);
+	exec_command_sync(MIRRDIR "/bin/busybox", "--install", "-s", BBPATH, NULL);
+	xsymlink(MIRRDIR "/bin/busybox", BBPATH "/busybox");
+}
+
+static int prepare_img() {
+	// First merge images
+	if (merge_img("/data/magisk_merge.img", MAINIMG)) {
+		LOGE("Image merge /data/magisk_merge.img -> " MAINIMG " failed!\n");
+		return 1;
+	}
+
+	if (access(MAINIMG, F_OK) == -1) {
+		if (create_img(MAINIMG, 64))
+			return 1;
+	}
+
+	LOGI("* Mounting " MAINIMG "\n");
+	// Mounting magisk image
+	char *magiskloop = mount_image(MAINIMG, MOUNTPOINT);
+	if (magiskloop == NULL)
+		return 1;
+
+	vec_init(&module_list);
+
+	xmkdir(COREDIR, 0755);
+	xmkdir(COREDIR "/post-fs-data.d", 0755);
+	xmkdir(COREDIR "/service.d", 0755);
+	xmkdir(COREDIR "/props", 0755);
+
+	DIR *dir = xopendir(MOUNTPOINT);
+	struct dirent *entry;
+	while ((entry = xreaddir(dir))) {
+		if (entry->d_type == DT_DIR) {
+			if (strcmp(entry->d_name, ".") == 0 ||
+				strcmp(entry->d_name, "..") == 0 ||
+				strcmp(entry->d_name, ".core") == 0 ||
+				strcmp(entry->d_name, "lost+found") == 0)
+				continue;
+			snprintf(buf, PATH_MAX, "%s/%s/remove", MOUNTPOINT, entry->d_name);
+			if (access(buf, F_OK) == 0) {
+				snprintf(buf, PATH_MAX, "%s/%s", MOUNTPOINT, entry->d_name);
+				rm_rf(buf);
+				continue;
+			}
+			snprintf(buf, PATH_MAX, "%s/%s/disable", MOUNTPOINT, entry->d_name);
+			if (access(buf, F_OK) == 0)
+				continue;
+			vec_push_back(&module_list, strdup(entry->d_name));
+		}
+	}
+
+	closedir(dir);
+
+	// Trim image
+	umount_image(MOUNTPOINT, magiskloop);
+	free(magiskloop);
+	trim_img(MAINIMG);
+
+	// Remount them back :)
+	magiskloop = mount_image(MAINIMG, MOUNTPOINT);
+	free(magiskloop);
+
+	// Fix file selinux contexts
+	fix_filecon();
+	return 0;
+}
+
+void fix_filecon() {
+	int dirfd = xopen(MOUNTPOINT, O_RDONLY | O_CLOEXEC);
+	restorecon(dirfd, 0);
+	close(dirfd);
+}
+
+/****************
+ * Entry points *
+ ****************/
+
+static void unblock_boot_process() {
+	close(xopen(UNBLOCKFILE, O_RDONLY | O_CREAT, 0));
+	pthread_exit(NULL);
+}
+
+void post_fs(int client) {
+	LOGI("** post-fs mode running\n");
+	// ack
+	write_int(client, 0);
+	close(client);
+
+	// Allow magiskinit to full patch
+	close(creat(PATCHSTART, 0));
+
+	// Uninstall or core only mode
+	if (access(UNINSTALLER, F_OK) == 0 || access(DISABLEFILE, F_OK) == 0)
+		goto unblock;
+
+	// Allocate buffer
+	buf = xmalloc(PATH_MAX);
+	buf2 = xmalloc(PATH_MAX);
+
+	simple_mount("/system");
+	simple_mount("/vendor");
+
+unblock:
+	unblock_boot_process();
+}
+
+void post_fs_data(int client) {
+	// ack
+	write_int(client, 0);
+	close(client);
+	if (!check_data())
+		goto unblock;
+
+	// Start the debug log
+	start_debug_full_log();
+
+	LOGI("** post-fs-data mode running\n");
+
+	// Allocate buffer
+	if (buf == NULL) buf = xmalloc(PATH_MAX);
+	if (buf2 == NULL) buf2 = xmalloc(PATH_MAX);
+
+	// Magisk binaries
+	char *bin_path = NULL;
+	if (access("/cache/data_bin", F_OK) == 0)
+		bin_path = "/cache/data_bin";
+	else if (access("/data/data/com.topjohnwu.magisk/install", F_OK) == 0)
+		bin_path = "/data/data/com.topjohnwu.magisk/install";
+	else if (access("/data/user_de/0/com.topjohnwu.magisk/install", F_OK) == 0)
+		bin_path = "/data/user_de/0/com.topjohnwu.magisk/install";
+	if (bin_path) {
+		rm_rf(DATABIN);
+		cp_afc(bin_path, DATABIN);
+		rm_rf(bin_path);
+	}
+
+	// Lazy.... use shell blob to match files
+	exec_command_sync("sh", "-c", "mv -f /data/magisk/stock_*.img.gz /data", NULL);
+
+	// Initialize
+	daemon_init();
+
+	// uninstaller
+	if (access(UNINSTALLER, F_OK) == 0) {
+		close(open(UNBLOCKFILE, O_RDONLY | O_CREAT));
+		setenv("BOOTMODE", "true", 1);
+		exec_command(0, NULL, bb_setenv, "sh", UNINSTALLER, NULL);
+		return;
+	}
+
+	// Merge, trim, mount magisk.img, which will also travel through the modules
+	// After this, it will create the module list
+	if (prepare_img())
+		goto core_only; // Mounting fails, we can only do core only stuffs
+
+	// Run common scripts
+	LOGI("* Running post-fs-data.d scripts\n");
+	exec_common_script("post-fs-data");
+
+	// Core only mode
+	if (access(DISABLEFILE, F_OK) == 0)
+		goto core_only;
+
+	// Execute module scripts
+	LOGI("* Running module post-fs-data scripts\n");
+	exec_module_script("post-fs-data");
+
+	char *module;
+	struct node_entry *sys_root, *ven_root = NULL, *child;
+
+	// Create the system root entry
+	sys_root = xcalloc(sizeof(*sys_root), 1);
+	sys_root->name = strdup("system");
+	sys_root->status = IS_INTER;
+
+	int has_modules = 0;
+
+	LOGI("* Loading modules\n");
+	vec_for_each(&module_list, module) {
+		// Read props
+		snprintf(buf, PATH_MAX, "%s/%s/system.prop", MOUNTPOINT, module);
+		if (access(buf, F_OK) == 0) {
+			LOGI("%s: loading [system.prop]\n", module);
+			read_prop_file(buf, 0);
+		}
+		// Check whether enable auto_mount
+		snprintf(buf, PATH_MAX, "%s/%s/auto_mount", MOUNTPOINT, module);
+		if (access(buf, F_OK) == -1)
+			continue;
+		// Double check whether the system folder exists
+		snprintf(buf, PATH_MAX, "%s/%s/system", MOUNTPOINT, module);
+		if (access(buf, F_OK) == -1)
+			continue;
+
+		// Construct structure
+		has_modules = 1;
+		LOGI("%s: constructing magic mount structure\n", module);
+		// If /system/vendor exists in module, create a link outside
+		snprintf(buf, PATH_MAX, "%s/%s/system/vendor", MOUNTPOINT, module);
+		if (access(buf, F_OK) == 0) {
+			snprintf(buf2, PATH_MAX, "%s/%s/vendor", MOUNTPOINT, module);
+			unlink(buf2);
+			xsymlink(buf, buf2);
+		}
+		construct_tree(module, sys_root);
+	}
+
+	if (has_modules) {
+		// Extract the vendor node out of system tree and swap with placeholder
+		vec_for_each(sys_root->children, child) {
+			if (strcmp(child->name, "vendor") == 0) {
+				ven_root = child;
+				child = xcalloc(sizeof(*child), 1);
+				child->type = seperate_vendor ? DT_LNK : DT_DIR;
+				child->parent = ven_root->parent;
+				child->name = strdup("vendor");
+				child->status = 0;
+				// Swap!
+				vec_cur(sys_root->children) = child;
+				ven_root->parent = NULL;
+				break;
+			}
+		}
+
+		// Magic!!
+		magic_mount(sys_root);
+		if (ven_root) magic_mount(ven_root);
+	}
+
+	// Cleanup memory
+	destroy_subtree(sys_root);
+	if (ven_root) destroy_subtree(ven_root);
+
+core_only:
+	// Systemless hosts
+	if (access(HOSTSFILE, F_OK) == 0) {
+		LOGI("* Enabling systemless hosts file support");
+		bind_mount(HOSTSFILE, "/system/etc/hosts");
+	}
+
+	auto_start_magiskhide();
+
+unblock:
+	unblock_boot_process();
+}
+
+void late_start(int client) {
+	LOGI("** late_start service mode running\n");
+	// ack
+	write_int(client, 0);
+	close(client);
+
+	// Allocate buffer
+	if (buf == NULL) buf = xmalloc(PATH_MAX);
+	if (buf2 == NULL) buf2 = xmalloc(PATH_MAX);
+
+	// Wait till the full patch is done
+	while (access(PATCHDONE, F_OK) == -1)
+		usleep(500); /* Wait 0.5ms */
+	unlink(PATCHDONE);
+
+	// Run scripts after full patch, most reliable way to run scripts
+	LOGI("* Running service.d scripts\n");
+	exec_common_script("service");
+
+	// Core only mode
+	if (access(DISABLEFILE, F_OK) == 0)
+		goto core_only;
+
+	LOGI("* Running module service scripts\n");
+	exec_module_script("service");
+
+core_only:
+	// Install Magisk Manager if exists
+	if (access(MANAGERAPK, F_OK) == 0) {
+		while (1) {
+			sleep(5);
+			int apk_res = -1, pid;
+			pid = exec_command(1, &apk_res, pm_setenv,
+				"app_process",
+				"/system/bin", "com.android.commands.pm.Pm",
+				"install", "-r", MANAGERAPK, NULL);
+			if (pid != -1) {
+				waitpid(pid, NULL, 0);
+				fdgets(buf, PATH_MAX, apk_res);
+				close(apk_res);
+				// Keep trying until pm is started
+				if (strstr(buf, "Error:") == NULL)
+					break;
+			}
+		}
+		unlink(MANAGERAPK);
+	}
+
+	// All boot stage done, cleanup everything
+	free(buf);
+	free(buf2);
+	buf = buf2 = NULL;
+	vec_deep_destroy(&module_list);
+
+	stop_debug_full_log();
+}

jni/core/daemon.c

@@ -0,0 +1,334 @@
+/* daemon.c - Magisk Daemon
+ *
+ * Start the daemon and wait for requests
+ * Connect the daemon and send requests through sockets
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/un.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <selinux/selinux.h>
+
+#include "magisk.h"
+#include "utils.h"
+#include "daemon.h"
+#include "magiskpolicy.h"
+#include "resetprop.h"
+
+pthread_t sepol_patch;
+int is_restart = 0;
+
+static void *request_handler(void *args) {
+	int client = *((int *) args);
+	free(args);
+	client_request req = read_int(client);
+
+	struct ucred credentials;
+	get_client_cred(client, &credentials);
+
+	switch (req) {
+	case LAUNCH_MAGISKHIDE:
+	case STOP_MAGISKHIDE:
+	case ADD_HIDELIST:
+	case RM_HIDELIST:
+	case LS_HIDELIST:
+	case POST_FS:
+	case POST_FS_DATA:
+	case LATE_START:
+		if (credentials.uid != 0) {
+			write_int(client, ROOT_REQUIRED);
+			close(client);
+			return NULL;
+		}
+	default:
+		break;
+	}
+
+	switch (req) {
+	case LAUNCH_MAGISKHIDE:
+		launch_magiskhide(client);
+		break;
+	case STOP_MAGISKHIDE:
+		stop_magiskhide(client);
+		break;
+	case ADD_HIDELIST:
+		add_hide_list(client);
+		break;
+	case RM_HIDELIST:
+		rm_hide_list(client);
+		break;
+	case LS_HIDELIST:
+		ls_hide_list(client);
+		break;
+	case SUPERUSER:
+		su_daemon_receiver(client);
+		break;
+	case CHECK_VERSION:
+		write_string(client, MAGISK_VER_STR);
+		close(client);
+		break;
+	case CHECK_VERSION_CODE:
+		write_int(client, MAGISK_VER_CODE);
+		close(client);
+		break;
+	case POST_FS:
+		post_fs(client);
+		break;
+	case POST_FS_DATA:
+		post_fs_data(client);
+		break;
+	case LATE_START:
+		late_start(client);
+		break;
+	default:
+		break;
+	}
+	return NULL;
+}
+
+/* Setup the address and return socket fd */
+static int setup_socket(struct sockaddr_un *sun) {
+	int fd = xsocket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
+	memset(sun, 0, sizeof(*sun));
+	sun->sun_family = AF_LOCAL;
+	memcpy(sun->sun_path, REQUESTOR_DAEMON_PATH, sizeof(REQUESTOR_DAEMON_PATH) - 1);
+	return fd;
+}
+
+static void *start_magisk_hide(void *args) {
+	launch_magiskhide(-1);
+	return NULL;
+}
+
+void auto_start_magiskhide() {
+	char *hide_prop = getprop2(MAGISKHIDE_PROP, 1);
+	if (hide_prop == NULL || strcmp(hide_prop, "0") != 0) {
+		pthread_t thread;
+		xpthread_create(&thread, NULL, start_magisk_hide, NULL);
+		pthread_detach(thread);
+	}
+	free(hide_prop);
+}
+
+void start_daemon() {
+	setsid();
+	setcon("u:r:su:s0");
+	umask(0);
+	int fd = xopen("/dev/null", O_RDWR | O_CLOEXEC);
+	xdup2(fd, STDIN_FILENO);
+	xdup2(fd, STDOUT_FILENO);
+	xdup2(fd, STDERR_FILENO);
+	close(fd);
+
+	// Block user signals
+	sigset_t block_set;
+	sigemptyset(&block_set);
+	sigaddset(&block_set, SIGUSR1);
+	sigaddset(&block_set, SIGUSR2);
+	pthread_sigmask(SIG_SETMASK, &block_set, NULL);
+
+	struct sockaddr_un sun;
+	fd = setup_socket(&sun);
+
+	xbind(fd, (struct sockaddr*) &sun, sizeof(sun));
+	xlisten(fd, 10);
+
+	if ((is_restart = access(MAGISKTMP, F_OK) == 0)) {
+		// Restart stuffs if the daemon is restarted
+		exec_command_sync("logcat", "-b", "all", "-c", NULL);
+		auto_start_magiskhide();
+		start_debug_log();
+	}
+
+	// Start the log monitor
+	monitor_logs();
+
+	LOGI("Magisk v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") daemon started\n");
+
+	// Change process name
+	strcpy(argv0, "magisk_daemon");
+
+	// Unlock all blocks for rw
+	unlock_blocks();
+
+	// Notifiy init the daemon is started
+	close(xopen(UNBLOCKFILE, O_RDONLY | O_CREAT));
+
+	// Loop forever to listen for requests
+	while(1) {
+		int *client = xmalloc(sizeof(int));
+		*client = xaccept4(fd, NULL, NULL, SOCK_CLOEXEC);
+		pthread_t thread;
+		xpthread_create(&thread, NULL, request_handler, client);
+		// Detach the thread, we will never join it
+		pthread_detach(thread);
+	}
+}
+
+/* Connect the daemon, and return a socketfd */
+int connect_daemon() {
+	struct sockaddr_un sun;
+	int fd = setup_socket(&sun);
+	if (xconnect(fd, (struct sockaddr*) &sun, sizeof(sun))) {
+		// If we cannot access the daemon, we start a daemon in the child process if possible
+
+		if (getuid() != UID_ROOT || getgid() != UID_ROOT) {
+			fprintf(stderr, "No daemon is currently running!\n");
+			exit(1);
+		}
+
+		if (xfork() == 0) {
+			LOGD("client: connect fail, try launching new daemon process\n");
+			close(fd);
+			start_daemon();
+		}
+
+		do {
+			// Wait for 10ms
+			usleep(10);
+		} while (connect(fd, (struct sockaddr*) &sun, sizeof(sun)));
+	}
+	return fd;
+}
+
+/*
+ * Receive a file descriptor from a Unix socket.
+ * Contributed by @mkasick
+ *
+ * Returns the file descriptor on success, or -1 if a file
+ * descriptor was not actually included in the message
+ *
+ * On error the function terminates by calling exit(-1)
+ */
+int recv_fd(int sockfd) {
+    // Need to receive data from the message, otherwise don't care about it.
+    char iovbuf;
+
+    struct iovec iov = {
+        .iov_base = &iovbuf,
+        .iov_len  = 1,
+    };
+
+    char cmsgbuf[CMSG_SPACE(sizeof(int))];
+
+    struct msghdr msg = {
+        .msg_iov        = &iov,
+        .msg_iovlen     = 1,
+        .msg_control    = cmsgbuf,
+        .msg_controllen = sizeof(cmsgbuf),
+    };
+
+    xrecvmsg(sockfd, &msg, MSG_WAITALL);
+
+    // Was a control message actually sent?
+    switch (msg.msg_controllen) {
+    case 0:
+        // No, so the file descriptor was closed and won't be used.
+        return -1;
+    case sizeof(cmsgbuf):
+        // Yes, grab the file descriptor from it.
+        break;
+    default:
+        goto error;
+    }
+
+    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
+
+    if (cmsg             == NULL                  ||
+        cmsg->cmsg_len   != CMSG_LEN(sizeof(int)) ||
+        cmsg->cmsg_level != SOL_SOCKET            ||
+        cmsg->cmsg_type  != SCM_RIGHTS) {
+error:
+        LOGE("unable to read fd");
+        exit(-1);
+    }
+
+    return *(int *)CMSG_DATA(cmsg);
+}
+
+/*
+ * Send a file descriptor through a Unix socket.
+ * Contributed by @mkasick
+ *
+ * On error the function terminates by calling exit(-1)
+ *
+ * fd may be -1, in which case the dummy data is sent,
+ * but no control message with the FD is sent.
+ */
+void send_fd(int sockfd, int fd) {
+    // Need to send some data in the message, this will do.
+    struct iovec iov = {
+        .iov_base = "",
+        .iov_len  = 1,
+    };
+
+    struct msghdr msg = {
+        .msg_iov        = &iov,
+        .msg_iovlen     = 1,
+    };
+
+    char cmsgbuf[CMSG_SPACE(sizeof(int))];
+
+    if (fd != -1) {
+        // Is the file descriptor actually open?
+        if (fcntl(fd, F_GETFD) == -1) {
+            if (errno != EBADF) {
+                PLOGE("unable to send fd");
+            }
+            // It's closed, don't send a control message or sendmsg will EBADF.
+        } else {
+            // It's open, send the file descriptor in a control message.
+            msg.msg_control    = cmsgbuf;
+            msg.msg_controllen = sizeof(cmsgbuf);
+
+            struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
+
+            cmsg->cmsg_len   = CMSG_LEN(sizeof(int));
+            cmsg->cmsg_level = SOL_SOCKET;
+            cmsg->cmsg_type  = SCM_RIGHTS;
+
+            *(int *)CMSG_DATA(cmsg) = fd;
+        }
+    }
+
+    xsendmsg(sockfd, &msg, 0);
+}
+
+int read_int(int fd) {
+    int val;
+    xxread(fd, &val, sizeof(int));
+    return val;
+}
+
+void write_int(int fd, int val) {
+    if (fd < 0) return;
+    xwrite(fd, &val, sizeof(int));
+}
+
+char* read_string(int fd) {
+    int len = read_int(fd);
+    if (len > PATH_MAX || len < 0) {
+        LOGE("invalid string length %d", len);
+        exit(1);
+    }
+    char* val = xmalloc(sizeof(char) * (len + 1));
+    xxread(fd, val, len);
+    val[len] = '\0';
+    return val;
+}
+
+void write_string(int fd, const char* val) {
+    if (fd < 0) return;
+    int len = strlen(val);
+    write_int(fd, len);
+    xwrite(fd, val, len);
+}

jni/core/log_monitor.c

@@ -0,0 +1,155 @@
+/* log_monitor.c - New thread to monitor logcat
+ *
+ * A universal logcat monitor for many usages. Add listeners to the list,
+ * and the pointer of the new log line will be sent through pipes to trigger
+ * asynchronous events without polling
+ */
+
+#include <stdio.h>
+#include <limits.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "magisk.h"
+#include "utils.h"
+
+int logcat_events[] = { -1, -1, -1 };
+extern int is_restart;
+
+#ifdef MAGISK_DEBUG
+static int debug_log_pid, debug_log_fd;
+#endif
+
+static void *logger_thread(void *args) {
+	int log_fd = -1, log_pid;
+	char line[4096];
+
+	LOGD("log_monitor: logger start");
+
+	while (1) {
+		// Start logcat
+		log_pid = exec_command(0, &log_fd, NULL, "logcat", "-b", "all" , "-v", "threadtime", "-s", "am_proc_start", "Magisk", NULL);
+		while (fdgets(line, sizeof(line), log_fd)) {
+			for (int i = 0; i < (sizeof(logcat_events) / sizeof(int)); ++i) {
+				if (logcat_events[i] > 0) {
+					char *s = strdup(line);
+					xwrite(logcat_events[i], &s, sizeof(s));
+				}
+			}
+			if (kill(log_pid, 0))
+				break;
+		}
+		// Clear buffer if restart required
+		exec_command_sync("logcat", "-b", "all", "-c", NULL);
+	}
+
+	// Should never be here, but well...
+	return NULL;
+}
+
+static void *magisk_log_thread(void *args) {
+	int have_data = 0;
+
+	// Temp buffer for logs before we have data access
+	struct vector logs;
+	vec_init(&logs);
+
+	FILE *log;
+	int pipefd[2];
+	if (xpipe2(pipefd, O_CLOEXEC) == -1)
+		return NULL;
+
+	// Register our listener
+	logcat_events[LOG_EVENT] = pipefd[1];
+
+	LOGD("log_monitor: magisk log dumper start");
+
+	for (char *line; xxread(pipefd[0], &line, sizeof(line)) > 0; free(line)) {
+		char *ss;
+		if ((ss = strstr(line, " Magisk")) && (ss[-1] != 'D') && (ss[-1] != 'V')) {
+			if (!have_data) {
+				if ((have_data = check_data())) {
+					// Dump buffered logs to file
+					if (!is_restart)
+						rename(LOGFILE, LASTLOG);
+					log = xfopen(LOGFILE, "a");
+					setbuf(log, NULL);
+					char *tmp;
+					vec_for_each(&logs, tmp) {
+						fprintf(log, "%s", tmp);
+						free(tmp);
+					}
+					vec_destroy(&logs);
+				} else {
+					vec_push_back(&logs, strdup(line));
+				}
+			}
+			if (have_data)
+				fprintf(log, "%s", line);
+		}
+	}
+	return NULL;
+}
+
+static void *debug_magisk_log_thread(void *args) {
+	FILE *log = xfopen(DEBUG_LOG, "a");
+	setbuf(log, NULL);
+	int pipefd[2];
+	if (xpipe2(pipefd, O_CLOEXEC) == -1)
+		return NULL;
+
+	LOGD("log_monitor: debug log dumper start");
+
+	// Register our listener
+	logcat_events[DEBUG_EVENT] = pipefd[1];
+
+	for (char *line; xxread(pipefd[0], &line, sizeof(line)) > 0; free(line)) {
+		char *ss;
+		if ((ss = strstr(line, "Magisk")))
+			fprintf(log, "%s", line);
+	}
+	return NULL;
+}
+
+/* Start new threads to monitor logcat and dump to logfile */
+void monitor_logs() {
+	pthread_t thread;
+
+	// Start log file dumper before monitor
+	xpthread_create(&thread, NULL, magisk_log_thread, NULL);
+	pthread_detach(thread);
+
+	// Start logcat monitor
+	xpthread_create(&thread, NULL, logger_thread, NULL);
+	pthread_detach(thread);
+
+}
+
+void start_debug_full_log() {
+#ifdef MAGISK_DEBUG
+	// Log everything initially
+	debug_log_fd = xopen(DEBUG_LOG, O_WRONLY | O_CREAT | O_CLOEXEC | O_TRUNC, 0644);
+	debug_log_pid = exec_command(0, &debug_log_fd, NULL, "logcat", "-v", "threadtime", NULL);
+	close(debug_log_fd);
+#endif
+}
+
+void stop_debug_full_log() {
+#ifdef MAGISK_DEBUG
+	// Stop recording the boot logcat after every boot task is done
+	kill(debug_log_pid, SIGTERM);
+	waitpid(debug_log_pid, NULL, 0);
+	// Start debug thread
+	start_debug_log();
+#endif
+}
+
+void start_debug_log() {
+#ifdef MAGISK_DEBUG
+	pthread_t thread;
+	// Start debug thread
+	xpthread_create(&thread, NULL, debug_magisk_log_thread, NULL);
+	pthread_detach(thread);
+#endif
+}

jni/core/magisk.c

@@ -0,0 +1,180 @@
+/* main.c - The multicall entry point
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <libgen.h>
+
+#include "utils.h"
+#include "magisk.h"
+#include "daemon.h"
+
+char *argv0;
+
+char *applet[] =
+	{ "su", "resetprop", "magiskhide", NULL };
+
+int (*applet_main[]) (int, char *[]) =
+	{ su_client_main, resetprop_main, magiskhide_main, NULL };
+
+int create_links(const char *bin, const char *path) {
+	char self[PATH_MAX], linkpath[PATH_MAX];
+	if (bin == NULL) {
+		xreadlink("/proc/self/exe", self, sizeof(self));
+		bin = self;
+	}
+	int ret = 0;
+	for (int i = 0; applet[i]; ++i) {
+		snprintf(linkpath, sizeof(linkpath), "%s/%s", path, applet[i]);
+		unlink(linkpath);
+		ret |= symlink(bin, linkpath);
+	}
+	return ret;
+}
+
+static void usage() {
+	fprintf(stderr,
+		"Magisk v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") (by topjohnwu) multi-call binary\n"
+		"\n"
+		"Usage: %s [applet [arguments]...]\n"
+		"   or: %s [options]...\n"
+		"\n"
+		"Options:\n"
+		"   -c                        print current binary version\n"
+		"   -v                        print running daemon version\n"
+		"   -V                        print running daemon version code\n"
+		"   --list                    list all availible applets\n"
+		"   --install [SOURCE] DIR    symlink all applets to DIR. SOURCE is optional\n"
+		"   --createimg IMG SIZE      create ext4 image. SIZE is interpreted in MB\n"
+		"   --imgsize IMG             report ext4 image used/total size\n"
+		"   --resizeimg IMG SIZE      resize ext4 image. SIZE is interpreted in MB\n"
+		"   --mountimg IMG PATH       mount IMG to PATH and prints the loop device\n"
+		"   --umountimg PATH LOOP     unmount PATH and delete LOOP device\n"
+		"   --[init service]          start init service\n"
+		"   --unlock-blocks           set BLKROSET flag to OFF for all block devices\n"
+		"   --restorecon              fix selinux context on Magisk files and folders\n"
+		"   --clone-attr SRC DEST     clone permission, owner, and selinux context\n"
+		"\n"
+		"Supported init services:\n"
+		"   daemon, post-fs, post-fs-data, service\n"
+		"\n"
+		"Supported applets:\n"
+	, argv0, argv0);
+
+	for (int i = 0; applet[i]; ++i)
+		fprintf(stderr, i ? ", %s" : "    %s", applet[i]);
+	fprintf(stderr, "\n\n");
+	exit(1);
+}
+
+int main(int argc, char *argv[]) {
+	argv0 = argv[0];
+	if (strcmp(basename(argv[0]), "magisk") == 0) {
+		if (argc < 2) usage();
+		if (strcmp(argv[1], "-c") == 0) {
+			printf("%s\n", MAGISK_VER_STR);
+			return 0;
+		} else if (strcmp(argv[1], "-v") == 0) {
+			int fd = connect_daemon();
+			write_int(fd, CHECK_VERSION);
+			char *v = read_string(fd);
+			printf("%s\n", v);
+			free(v);
+			return 0;
+		} else if (strcmp(argv[1], "-V") == 0) {
+			int fd = connect_daemon();
+			write_int(fd, CHECK_VERSION_CODE);
+			printf("%d\n", read_int(fd));
+			return 0;
+		} else if (strcmp(argv[1], "--install") == 0) {
+			if (argc < 3) usage();
+			if (argc == 3) return create_links(NULL, argv[2]);
+			else return create_links(argv[2], argv[3]);
+		} else if (strcmp(argv[1], "--list") == 0) {
+			for (int i = 0; applet[i]; ++i)
+				printf("%s\n", applet[i]);
+			return 0;
+		} else if (strcmp(argv[1], "--createimg") == 0) {
+			if (argc < 4) usage();
+			int size;
+			sscanf(argv[3], "%d", &size);
+			return create_img(argv[2], size);
+		} else if (strcmp(argv[1], "--imgsize") == 0) {
+			if (argc < 3) usage();
+			int used, total;
+			if (get_img_size(argv[2], &used, &total)) {
+				fprintf(stderr, "Cannot check %s size\n", argv[2]);
+				return 1;
+			}
+			printf("%d %d\n", used, total);
+			return 0;
+		} else if (strcmp(argv[1], "--resizeimg") == 0) {
+			if (argc < 4) usage();
+			int used, total, size;
+			sscanf(argv[3], "%d", &size);
+			if (get_img_size(argv[2], &used, &total)) {
+				fprintf(stderr, "Cannot check %s size\n", argv[2]);
+				return 1;
+			}
+			if (size <= used) {
+				fprintf(stderr, "Cannot resize smaller than %dM\n", used);
+				return 1;
+			}
+			return resize_img(argv[2], size);
+		} else if (strcmp(argv[1], "--mountimg") == 0) {
+			if (argc < 4) usage();
+			char *loop = mount_image(argv[2], argv[3]);
+			if (loop == NULL) {
+				fprintf(stderr, "Cannot mount image!\n");
+				return 1;
+			} else {
+				printf("%s\n", loop);
+				free(loop);
+				return 0;
+			}
+		} else if (strcmp(argv[1], "--umountimg") == 0) {
+			if (argc < 4) usage();
+			umount_image(argv[2], argv[3]);
+			return 0;
+		} else if (strcmp(argv[1], "--unlock-blocks") == 0) {
+			unlock_blocks();
+			return 0;
+		} else if (strcmp(argv[1], "--restorecon") == 0) {
+			fix_filecon();
+			return 0;
+		} else if (strcmp(argv[1], "--clone-attr") == 0) {
+			if (argc < 4) usage();
+			clone_attr(argv[2], argv[3]);
+			return 0;
+		} else if (strcmp(argv[1], "--daemon") == 0) {
+			// Start daemon, this process won't return
+			start_daemon();
+		} else if (strcmp(argv[1], "--post-fs") == 0) {
+			int fd = connect_daemon();
+			write_int(fd, POST_FS);
+			return read_int(fd);
+		} else if (strcmp(argv[1], "--post-fs-data") == 0) {
+			int fd = connect_daemon();
+			write_int(fd, POST_FS_DATA);
+			return read_int(fd);
+		} else if (strcmp(argv[1], "--service") == 0) {
+			int fd = connect_daemon();
+			write_int(fd, LATE_START);
+			return read_int(fd);
+		} else {
+			// It's calling applets
+			--argc;
+			++argv;
+		}
+	}
+
+	// Applets
+	for (int i = 0; applet[i]; ++i) {
+		if (strcmp(basename(argv[0]), applet[i]) == 0)
+			return (*applet_main[i])(argc, argv);
+	}
+
+	fprintf(stderr, "%s: applet not found\n", basename(argv[0]));
+	return 1;
+}

jni/core/magiskinit.c

@@ -0,0 +1,441 @@
+/* magiskinit.c - Pre-init Magisk support
+ *
+ * This code has to be compiled statically to work properly.
+ *
+ * To unify Magisk support for both legacy "normal" devices and new skip_initramfs devices,
+ * magisk binary compilation is split into two parts - first part only compiles "magisk".
+ * The python build script will load the magisk main binary and compress with lzma2, dumping
+ * the results into "dump.h". The "magisk" binary is embedded into this binary, and will
+ * get extracted to the overlay folder along with init.magisk.rc.
+ *
+ * This tool does all pre-init operations to setup a Magisk environment, which pathces rootfs
+ * on the fly, providing fundamental support such as init, init.rc, and sepolicy patching.
+ *
+ * Magiskinit is also responsible for constructing a proper rootfs on skip_initramfs devices.
+ * On skip_initramfs devices, it will parse kernel cmdline, mount sysfs, parse through
+ * uevent files to make the system (or vendor if available) block device node, then copy
+ * rootfs files from system.
+ *
+ * This tool will be replaced with the real init to continue the boot process, but hardlinks are
+ * preserved as it also provides CLI for sepolicy patching (magiskpolicy)
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/mman.h>
+#include <sys/sendfile.h>
+#include <sys/sysmacros.h>
+
+#include <lzma.h>
+#include <cil/cil.h>
+
+#include "magisk.h"
+#include "utils.h"
+#include "magiskpolicy.h"
+#include "magiskrc.h"
+#include "dump.h"
+
+// #define VLOG(fmt, ...) printf(fmt, __VA_ARGS__)   /* Enable to debug */
+#define VLOG(fmt, ...)
+
+struct cmdline {
+	int skip_initramfs;
+	char slot[3];
+};
+
+struct device {
+	dev_t major;
+	dev_t minor;
+	char devname[32];
+	char partname[32];
+	char path[64];
+};
+
+extern policydb_t *policydb;
+
+static void parse_cmdline(struct cmdline *cmd) {
+	// cleanup
+	cmd->skip_initramfs = 0;
+	cmd->slot[0] = '\0';
+
+	char *tok;
+	char cmdline[4096];
+	mkdir("/proc", 0555);
+	mount("proc", "/proc", "proc", 0, NULL);
+	int fd = open("/proc/cmdline", O_RDONLY | O_CLOEXEC);
+	cmdline[read(fd, cmdline, sizeof(cmdline))] = '\0';
+	close(fd);
+	umount("/proc");
+	tok = strtok(cmdline, " ");
+	while (tok != NULL) {
+		if (strncmp(tok, "androidboot.slot_suffix", 23) == 0) {
+			sscanf(tok, "androidboot.slot_suffix=%s", cmd->slot);
+		} else if (strncmp(tok, "androidboot.slot", 16) == 0) {
+			cmd->slot[0] = '_';
+			sscanf(tok, "androidboot.slot=%s", cmd->slot + 1);
+		} else if (strcmp(tok, "skip_initramfs") == 0) {
+			cmd->skip_initramfs = 1;
+		}
+		tok = strtok(NULL, " ");
+	}
+}
+
+static void parse_device(struct device *dev, char *uevent) {
+	dev->partname[0] = '\0';
+	char *tok;
+	tok = strtok(uevent, "\n");
+	while (tok != NULL) {
+		if (strncmp(tok, "MAJOR", 5) == 0) {
+			sscanf(tok, "MAJOR=%ld", (long*) &dev->major);
+		} else if (strncmp(tok, "MINOR", 5) == 0) {
+			sscanf(tok, "MINOR=%ld", (long*) &dev->minor);
+		} else if (strncmp(tok, "DEVNAME", 7) == 0) {
+			sscanf(tok, "DEVNAME=%s", dev->devname);
+		} else if (strncmp(tok, "PARTNAME", 8) == 0) {
+			sscanf(tok, "PARTNAME=%s", dev->partname);
+		}
+		tok = strtok(NULL, "\n");
+	}
+	VLOG("%s [%s] (%u, %u)\n", dev->devname, dev->partname, (unsigned) dev->major, (unsigned) dev->minor);
+}
+
+static int setup_block(struct device *dev, const char *partname) {
+	char buffer[1024], path[128];
+	struct dirent *entry;
+	DIR *dir = opendir("/sys/dev/block");
+	if (dir == NULL)
+		return 1;
+	int found = 0;
+	while ((entry = readdir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		snprintf(path, sizeof(path), "/sys/dev/block/%s/uevent", entry->d_name);
+		int fd = open(path, O_RDONLY | O_CLOEXEC);
+		ssize_t size = read(fd, buffer, sizeof(buffer));
+		buffer[size] = '\0';
+		close(fd);
+		parse_device(dev, buffer);
+		if (strcmp(dev->partname, partname) == 0) {
+			snprintf(dev->path, sizeof(dev->path), "/dev/block/%s", dev->devname);
+			found = 1;
+			break;
+		}
+	}
+	closedir(dir);
+
+	if (!found)
+		return 1;
+
+	mkdir("/dev", 0755);
+	mkdir("/dev/block", 0755);
+	mknod(dev->path, S_IFBLK | 0600, makedev(dev->major, dev->minor));
+	return 0;
+}
+
+static void *patch_init_rc(char *data, uint32_t *size) {
+	int injected = 0;
+	char *new_data = malloc(*size + 23);
+	char *old_data = data;
+	uint32_t pos = 0;
+
+	for (char *tok = strsep(&old_data, "\n"); tok; tok = strsep(&old_data, "\n")) {
+		if (!injected && strncmp(tok, "import", 6) == 0) {
+			if (strstr(tok, "init.magisk.rc")) {
+				injected = 1;
+			} else {
+				strcpy(new_data + pos, "import /init.magisk.rc\n");
+				pos += 23;
+				injected = 1;
+			}
+		} else if (strstr(tok, "selinux.reload_policy")) {
+			continue;
+		}
+		// Copy the line
+		strcpy(new_data + pos, tok);
+		pos += strlen(tok);
+		new_data[pos++] = '\n';
+	}
+
+	*size = pos;
+	return new_data;
+}
+
+static void patch_ramdisk() {
+	void *addr;
+	size_t size;
+	mmap_rw("/init", &addr, &size);
+	for (int i = 0; i < size; ++i) {
+		if (memcmp(addr + i, "/system/etc/selinux/plat_sepolicy.cil", 37) == 0) {
+			memcpy(addr + i, "/system/etc/selinux/plat_sepolicy.xxx", 37);
+			break;
+		}
+	}
+	munmap(addr, size);
+
+	mmap_rw("/init.rc", &addr, &size);
+	uint32_t new_size = size;
+	void *init_rc = patch_init_rc(addr, &new_size);
+	munmap(addr, size);
+
+	int fd = open("/init.rc", O_WRONLY | O_TRUNC | O_CLOEXEC);
+	write(fd, init_rc, new_size);
+	close(fd);
+	free(init_rc);
+}
+
+static int strend(const char *s1, const char *s2) {
+	int l1 = strlen(s1);
+	int l2 = strlen(s2);
+	return strcmp(s1 + l1 - l2, s2);
+}
+
+static int compile_cil() {
+	DIR *dir;
+	struct dirent *entry;
+	char path[128];
+
+	struct cil_db *db = NULL;
+	sepol_policydb_t *pdb = NULL;
+	void *addr;
+	size_t size;
+
+	cil_db_init(&db);
+	cil_set_mls(db, 1);
+	cil_set_target_platform(db, SEPOL_TARGET_SELINUX);
+	cil_set_policy_version(db, POLICYDB_VERSION_XPERMS_IOCTL);
+	cil_set_attrs_expand_generated(db, 0);
+
+	// plat
+	mmap_ro("/system/etc/selinux/plat_sepolicy.cil", &addr, &size);
+	cil_add_file(db, "/system/etc/selinux/plat_sepolicy.cil", addr, size);
+	munmap(addr, size);
+
+	// mapping
+	char plat[10];
+	int fd = open("/vendor/etc/selinux/plat_sepolicy_vers.txt", O_RDONLY | O_CLOEXEC);
+	if (fd > 0) {
+		plat[read(fd, plat, sizeof(plat)) - 1] = '\0';
+		snprintf(path, sizeof(path), "/system/etc/selinux/mapping/%s.cil", plat);
+		mmap_ro(path, &addr, &size);
+		cil_add_file(db, path, addr, size);
+		munmap(addr, size);
+		close(fd);
+	}
+
+	dir = opendir("/vendor/etc/selinux");
+	while ((entry = readdir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (strend(entry->d_name, ".cil") == 0) {
+			snprintf(path, sizeof(path), "/vendor/etc/selinux/%s", entry->d_name);
+			mmap_ro(path, &addr, &size);
+			cil_add_file(db, path, addr, size);
+			munmap(addr, size);
+		}
+	}
+	closedir(dir);
+
+	cil_compile(db);
+	cil_build_policydb(db, &pdb);
+	cil_db_destroy(&db);
+
+	policydb = &pdb->p;
+
+	return 0;
+}
+
+static int verify_precompiled() {
+	DIR *dir;
+	struct dirent *entry;
+	int fd;
+	char sys_sha[70], ven_sha[70];
+
+	dir = opendir("/vendor/etc/selinux");
+	while ((entry = readdir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (strend(entry->d_name, ".sha256") == 0) {
+			fd = openat(dirfd(dir), entry->d_name, O_RDONLY | O_CLOEXEC);
+			ven_sha[read(fd, ven_sha, sizeof(ven_sha))] = '\0';
+			close(fd);
+			break;
+		}
+	}
+	closedir(dir);
+	dir = opendir("/system/etc/selinux");
+	while ((entry = readdir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (strend(entry->d_name, ".sha256") == 0) {
+			fd = openat(dirfd(dir), entry->d_name, O_RDONLY | O_CLOEXEC);
+			sys_sha[read(fd, sys_sha, sizeof(sys_sha))] = '\0';
+			close(fd);
+			break;
+		}
+	}
+	closedir(dir);
+	return strcmp(sys_sha, ven_sha);
+}
+
+static void patch_sepolicy() {
+	if (access("/sepolicy", R_OK) == 0) {
+		load_policydb("/sepolicy");
+	} else if (access("/vendor/etc/selinux/precompiled_sepolicy", R_OK) == 0
+		&& verify_precompiled() == 0) {
+		load_policydb("/vendor/etc/selinux/precompiled_sepolicy");
+	} else if (access("/system/etc/selinux/plat_sepolicy.cil", R_OK) == 0) {
+		compile_cil();
+	}
+
+	sepol_med_rules();
+	dump_policydb("/sepolicy");
+}
+
+#define BUFSIZE (1 << 20)
+
+static int unxz(const void *buf, size_t size, int fd) {
+	lzma_stream strm = LZMA_STREAM_INIT;
+	if (lzma_auto_decoder(&strm, UINT64_MAX, 0) != LZMA_OK)
+		return 1;
+	lzma_ret ret = 0;
+	void *out = malloc(BUFSIZE);
+	strm.next_in = buf;
+	strm.avail_in = size;
+	do {
+		strm.next_out = out;
+		strm.avail_out = BUFSIZE;
+		ret = lzma_code(&strm, LZMA_RUN);
+		write(fd, out, BUFSIZE - strm.avail_out);
+	} while (strm.avail_out == 0 && ret == LZMA_OK);
+
+	free(out);
+	lzma_end(&strm);
+
+	if (ret != LZMA_OK && ret != LZMA_STREAM_END)
+		return 1;
+	return 0;
+}
+
+static int dump_magisk(const char *path, mode_t mode) {
+	unlink(path);
+	int fd = creat(path, mode);
+	int ret = unxz(magisk_dump, sizeof(magisk_dump), fd);
+	close(fd);
+	return ret;
+}
+
+static int dump_magiskrc(const char *path, mode_t mode) {
+	int fd = creat(path, mode);
+	write(fd, magiskrc, sizeof(magiskrc));
+	close(fd);
+	return 0;
+}
+
+int main(int argc, char *argv[]) {
+	umask(0);
+
+	if (strcmp(basename(argv[0]), "magiskpolicy") == 0 || strcmp(basename(argv[0]), "supolicy") == 0)
+		return magiskpolicy_main(argc, argv);
+	if (argc > 1 && (strcmp(argv[1], "magiskpolicy") == 0 || strcmp(argv[1], "supolicy") == 0))
+		return magiskpolicy_main(argc - 1, argv + 1);
+
+	if (argc > 1 && strcmp(argv[1], "-x") == 0) {
+		if (strcmp(argv[2], "magisk") == 0)
+			return dump_magisk(argv[3], 0755);
+		else if (strcmp(argv[2], "magiskrc") == 0)
+			return dump_magiskrc(argv[3], 0755);
+	}
+
+	// Extract and link files
+	mkdir("/overlay", 0000);
+	dump_magiskrc("/overlay/init.magisk.rc", 0750);
+	mkdir("/overlay/sbin", 0755);
+	dump_magisk("/overlay/sbin/magisk", 0755);
+	mkdir("/overlay/root", 0755);
+	link("/init", "/overlay/root/magiskinit");
+	symlink("/root/magiskinit", "/overlay/root/magiskpolicy");
+	symlink("/root/magiskinit", "/overlay/root/supolicy");
+
+	struct cmdline cmd;
+	parse_cmdline(&cmd);
+
+	VLOG("cmdline: skip_initramfs=[%d] slot_suffix=[%s]\n", cmd.skip_initramfs, cmd.slot);
+
+	int root = open("/", O_RDONLY | O_CLOEXEC);
+
+	if (cmd.skip_initramfs) {
+		// Exclude overlay folder
+		excl_list = (char *[]) { "overlay", ".backup", NULL };
+		// Clear rootfs
+		frm_rf(root);
+
+		mkdir("/sys", 0755);
+		mount("sysfs", "/sys", "sysfs", 0, NULL);
+
+		char partname[32];
+		snprintf(partname, sizeof(partname), "system%s", cmd.slot);
+
+		struct device dev;
+		setup_block(&dev, partname);
+
+		mkdir("/system_root", 0755);
+		mount(dev.path, "/system_root", "ext4", MS_RDONLY, NULL);
+		int system_root = open("/system_root", O_RDONLY | O_CLOEXEC);
+
+		// Exclude system folder
+		excl_list = (char *[]) { "system", NULL };
+		clone_dir(system_root, root);
+		mkdir("/system", 0755);
+		mount("/system_root/system", "/system", NULL, MS_BIND, NULL);
+
+		snprintf(partname, sizeof(partname), "vendor%s", cmd.slot);
+
+		// We need to mount independent vendor partition
+		if (setup_block(&dev, partname) == 0)
+			mount(dev.path, "/vendor", "ext4", MS_RDONLY, NULL);
+
+		close(system_root);
+	} else {
+		// Revert original init binary
+		unlink("/init");
+		link("/.backup/init", "/init");
+	}
+
+	int overlay = open("/overlay", O_RDONLY | O_CLOEXEC);
+	mv_dir(overlay, root);
+
+	// Clean up
+	rmdir("/overlay");
+	close(overlay);
+	close(root);
+
+	patch_ramdisk();
+	patch_sepolicy();
+
+	umount("/vendor");
+
+	if (fork() == 0) {
+		// Fork a new process for full patch
+		setsid();
+		sepol_allow("su", ALL, ALL, ALL);
+		while (access(PATCHSTART, W_OK) == -1)
+			usleep(500); /* Wait 0.5ms */
+		unlink(PATCHSTART);
+		dump_policydb(SELINUX_LOAD);
+		close(open(PATCHDONE, O_RDONLY | O_CREAT, 0));
+		destroy_policydb();
+		return 0;
+	}
+
+	// Finally, give control back!
+	execv("/init", argv);
+}

jni/daemon/bootstages.c

@@ -1,773 +0,0 @@
-/* post_fs_data.c - post-fs-data actions
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
-#include <dirent.h>
-#include <linux/loop.h>
-#include <sys/ioctl.h>
-#include <sys/mount.h>
-#include <sys/wait.h>
-#include <selinux/selinux.h>
-
-#include "magisk.h"
-#include "utils.h"
-#include "daemon.h"
-#include "resetprop.h"
-
-static char *buf, *buf2;
-static struct vector module_list;
-
-#ifdef DEBUG
-static int debug_log_pid, debug_log_fd;
-#endif
-
-/******************
- * Node structure *
- ******************/
-
-// Precedence: MODULE > SKEL > DUMMY
-#define DO_NOTHING 0x0    /* intermediate node */
-#define IS_DUMMY   0x1    /* mount from mirror */
-#define IS_SKEL    0x2    /* mount from skeleton */
-#define IS_MODULE  0x4    /* mount from module */
-
-struct node_entry {
-	const char *module;    /* Only used when status & IS_MODULE */
-	char *name;
-	uint8_t type;
-	uint8_t status;
-	struct node_entry *parent;
-	struct vector *children;
-};
-
-#define IS_DIR(n)  (n->type == DT_DIR)
-#define IS_LNK(n)  (n->type == DT_LNK)
-#define IS_REG(n)  (n->type == DT_REG)
-
-/******************
- * Image handling *
- ******************/
-
-static char *loopsetup(const char *img) {
-	char device[20];
-	struct loop_info64 info;
-	int i, lfd, ffd;
-	memset(&info, 0, sizeof(info));
-	// First get an empty loop device
-	for (i = 0; i <= 7; ++i) {
-		sprintf(device, "/dev/block/loop%d", i);
-		lfd = xopen(device, O_RDWR);
-		if (ioctl(lfd, LOOP_GET_STATUS64, &info) == -1)
-			break;
-		close(lfd);
-	}
-	if (i == 8) return NULL;
-	ffd = xopen(img, O_RDWR);
-	if (ioctl(lfd, LOOP_SET_FD, ffd) == -1)
-		return NULL;
-	strcpy((char *) info.lo_file_name, img);
-	ioctl(lfd, LOOP_SET_STATUS64, &info);
-	close(lfd);
-	close(ffd);
-	return strdup(device);
-}
-
-static char *mount_image(const char *img, const char *target) {
-	char *device = loopsetup(img);
-	if (device)
-		xmount(device, target, "ext4", 0, NULL);
-	return device;
-}
-
-static void umount_image(const char *target, const char *device) {
-	xumount(target);
-	int fd = xopen(device, O_RDWR);
-	ioctl(fd, LOOP_CLR_FD);
-	close(fd);
-}
-
-#define round_size(a) ((((a) / 32) + 2) * 32)
-
-static int merge_img(const char *source, const char *target) {
-	if (access(source, F_OK) == -1)
-		return 0;
-	if (access(target, F_OK) == -1) {
-		rename(source, target);
-		return 0;
-	}
-	
-	// resize target to worst case
-	int s_used, s_total, t_used, t_total, n_total;
-	get_img_size(source, &s_used, &s_total);
-	get_img_size(target, &t_used, &t_total);
-	n_total = round_size(s_used + t_used);
-	if (n_total != t_total && resize_img(target, n_total))
-		return 1;
-
-	xmkdir("/cache/source", 0755);
-	xmkdir("/cache/target", 0755);
-	char *s_loop, *t_loop;
-	s_loop = mount_image(source, "/cache/source");
-	if (s_loop == NULL) return 1;
-	t_loop = mount_image(target, "/cache/target");
-	if (t_loop == NULL) return 1;
-
-	DIR *dir;
-	struct dirent *entry;
-	if (!(dir = opendir("/cache/source")))
-		return 1;
-	while ((entry = xreaddir(dir))) {
-		if (entry->d_type == DT_DIR) {
-			if (strcmp(entry->d_name, ".") == 0 ||
-				strcmp(entry->d_name, "..") == 0 ||
-				strcmp(entry->d_name, ".core") == 0 ||
-				strcmp(entry->d_name, "lost+found") == 0)
-				continue;
-			// Cleanup old module
-			snprintf(buf, PATH_MAX, "/cache/target/%s", entry->d_name);
-			if (access(buf, F_OK) == 0) {
-				LOGI("merge module %s\n", entry->d_name);
-				rm_rf(buf);
-			}
-		}
-	}
-	closedir(dir);
-	clone_dir("/cache/source", "/cache/target");
-
-	// Unmount all loop devices
-	umount_image("/cache/source", s_loop);
-	umount_image("/cache/target", t_loop);
-	rmdir("/cache/source");
-	rmdir("/cache/target");
-	free(s_loop);
-	free(t_loop);
-	unlink(source);
-	return 0;
-}
-
-static void trim_img(const char *img) {
-	int used, total, new_size;
-	get_img_size(img, &used, &total);
-	new_size = round_size(used);
-	if (new_size != total)
-		resize_img(img, new_size);
-}
-
-/***********
- * Scripts *
- ***********/
-
-void exec_common_script(const char* stage) {
-	DIR *dir;
-	struct dirent *entry;
-	snprintf(buf, PATH_MAX, "%s/%s.d", COREDIR, stage);
-
-	if (!(dir = opendir(buf)))
-		return;
-
-	while ((entry = xreaddir(dir))) {
-		if (entry->d_type == DT_REG) {
-			snprintf(buf2, PATH_MAX, "%s/%s", buf, entry->d_name);
-			if (access(buf2, X_OK) == -1)
-				continue;
-			LOGI("%s.d: exec [%s]\n", stage, entry->d_name);
-			char *const command[] = { "sh", buf2, NULL };
-			int pid = run_command(0, NULL, "/system/bin/sh", command);
-			if (pid != -1)
-				waitpid(pid, NULL, 0);
-		}
-	}
-
-	closedir(dir);
-}
-
-void exec_module_script(const char* stage) {
-	char *module;
-	vec_for_each(&module_list, module) {
-		snprintf(buf, PATH_MAX, "%s/%s/%s.sh", MOUNTPOINT, module, stage);
-		if (access(buf, F_OK) == -1)
-			continue;
-		LOGI("%s: exec [%s.sh]\n", module, stage);
-		char *const command[] = { "sh", buf, NULL };
-		int pid = run_command(0, NULL, "/system/bin/sh", command);
-		if (pid != -1)
-			waitpid(pid, NULL, 0);
-	}
-
-}
-
-/***************
- * Magic Mount *
- ***************/
-
-static char *get_full_path(struct node_entry *node) {
-	char buffer[PATH_MAX], temp[PATH_MAX];
-	// Concat the paths
-	struct node_entry *cur = node;
-	strcpy(buffer, node->name);
-	while (cur->parent) {
-		strcpy(temp, buffer);
-		snprintf(buffer, sizeof(buffer), "%s/%s", cur->parent->name, temp);
-		cur = cur->parent;
-	}
-	return strdup(buffer);
-}
-
-// Free the node
-static void destroy_node(struct node_entry *node) {
-	free(node->name);
-	vec_destroy(node->children);
-	free(node->children);
-	free(node);
-}
-
-// Free the node and all children recursively
-static void destroy_subtree(struct node_entry *node) {
-	// Never free parent, since it shall be freed by themselves
-	struct node_entry *e;
-	vec_for_each(node->children, e) {
-		destroy_subtree(e);
-	}
-	destroy_node(node);
-}
-
-// Return the child
-static struct node_entry *insert_child(struct node_entry *p, struct node_entry *c) {
-	c->parent = p;
-	if (p->children == NULL) {
-		p->children = xmalloc(sizeof(struct vector));
-		vec_init(p->children);
-	}
-	struct node_entry *e;
-	vec_for_each(p->children, e) {
-		if (strcmp(e->name, c->name) == 0) {
-			// Exist duplicate
-			if (c->status > e->status) {
-				// Precedence is higher, replace with new node
-				c->children = e->children;  // Preserve all children
-				free(e->name);
-				free(e);
-				vec_entry(p->children)[_] = c;
-				return c;
-			} else {
-				// Free the new entry, return old
-				destroy_node(c);
-				return e;
-			}
-		}
-	}
-	// New entry, push back
-	vec_push_back(p->children, c);
-	return c;
-}
-
-static void construct_tree(const char *module, struct node_entry *parent) {
-	DIR *dir;
-	struct dirent *entry;
-	struct node_entry *node;
-
-	char *parent_path = get_full_path(parent);
-	snprintf(buf, PATH_MAX, "%s/%s%s", MOUNTPOINT, module, parent_path);
-
-	if (!(dir = opendir(buf)))
-		goto cleanup;
-
-	while ((entry = xreaddir(dir))) {
-		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
-			continue;
-		// Create new node
-		node = xcalloc(sizeof(*node), 1);
-		node->module = module;
-		node->name = strdup(entry->d_name);
-		node->type = entry->d_type;
-		snprintf(buf, PATH_MAX, "%s/%s", parent_path, node->name);
-		// Check if the entry has a correspond target
-		if (IS_LNK(node) || access(buf, F_OK) == -1) {
-			// Mark the parent folder as a skeleton
-			parent->status |= IS_SKEL;
-			node->status |= IS_MODULE;
-		} else if (IS_DIR(node)) {
-			// Check if marked as replace
-			snprintf(buf2, PATH_MAX, "%s/%s%s/.replace", MOUNTPOINT, module, buf);
-			if (access(buf2, F_OK) == 0) {
-				// Replace everything, mark as leaf
-				node->status |= IS_MODULE;
-			}
-		} else if (IS_REG(node)) {
-			// This is a leaf, mark as target
-			node->status |= IS_MODULE;
-		}
-		node = insert_child(parent, node);
-		if (IS_DIR(node) && !(node->status & IS_MODULE)) {
-			// Intermediate node, travel deeper
-			construct_tree(module, node);
-		}
-	}
-	
-	closedir(dir);
-
-cleanup:
-	free(parent_path);
-}
-
-static void clone_skeleton(struct node_entry *node) {
-	DIR *dir;
-	struct dirent *entry;
-	struct node_entry *dummy, *child;
-
-	// Clone the structure
-	char *full_path = get_full_path(node);
-	if (!(dir = opendir(full_path)))
-		goto cleanup;
-	while ((entry = xreaddir(dir))) {
-		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
-			continue;
-		// Create dummy node
-		dummy = xcalloc(sizeof(*dummy), 1);
-		dummy->name = strdup(entry->d_name);
-		dummy->type = entry->d_type;
-		dummy->status |= IS_DUMMY;
-		insert_child(node, dummy);
-	}
-	closedir(dir);
-
-	snprintf(buf, PATH_MAX, "%s%s", DUMMDIR, full_path);
-	mkdir_p(buf, 0755);
-	clone_attr(full_path, buf);
-	bind_mount(buf, full_path);
-
-	vec_for_each(node->children, child) {
-		snprintf(buf, PATH_MAX, "%s%s/%s", DUMMDIR, full_path, child->name);
-		// Create the dummy file/directory
-		if (IS_DIR(child))
-			xmkdir(buf, 0755);
-		else if (IS_REG(child))
-			close(open_new(buf));
-
-		if (child->status & IS_MODULE) {
-			// Mount from module file to dummy file
-			snprintf(buf2, PATH_MAX, "%s/%s%s/%s", MOUNTPOINT, child->module, full_path, child->name);
-		} else if (child->status & IS_SKEL) {
-			// It's another skeleton, recursive call and end
-			clone_skeleton(child);
-			continue;
-		} else if (child->status & IS_DUMMY) {
-			// Mount from mirror to dummy file
-			snprintf(buf2, PATH_MAX, "%s%s/%s", MIRRDIR, full_path, child->name);
-		}
-
-		if (IS_LNK(child)) {
-			// Symlink special treatments
-			char *temp = xmalloc(PATH_MAX);
-			xreadlink(buf2, temp, PATH_MAX);
-			symlink(temp, buf);
-			free(temp);
-			LOGI("cplink: %s -> %s\n", buf2, buf);
-		} else {
-			snprintf(buf, PATH_MAX, "%s/%s", full_path, child->name);
-			bind_mount(buf2, buf);
-		}
-	}
-
-cleanup:
-	free(full_path);
-}
-
-static void magic_mount(struct node_entry *node) {
-	char *real_path;
-	struct node_entry *child;
-
-	if (strcmp(node->name, "vendor") == 0 && strcmp(node->parent->name, "/system") == 0) {
-		snprintf(buf, PATH_MAX, "%s/%s/system/vendor", MOUNTPOINT, node->module);
-		snprintf(buf2, PATH_MAX, "%s/%s/vendor", MOUNTPOINT, node->module);
-		unlink(buf2);
-		symlink(buf, buf2);
-		return;
-	}
-
-	if (node->status) {
-		if (node->status & IS_MODULE) {
-			// The real deal, mount module item
-			real_path = get_full_path(node);
-			snprintf(buf, PATH_MAX, "%s/%s%s", MOUNTPOINT, node->module, real_path);
-			bind_mount(buf, real_path);
-			free(real_path);
-		} else if (node->status & IS_SKEL) {
-			// The node is labeled to be cloned with skeleton, lets do it
-			clone_skeleton(node);
-		}
-		// We should not see dummies, so no need to handle it here
-	} else {
-		// It's an intermediate node, travel deeper
-		vec_for_each(node->children, child)
-			magic_mount(child);
-	}
-}
-
-/****************
- * Simple Mount *
- ****************/
-
-static void simple_mount(const char *path) {
-	DIR *dir;
-	struct dirent *entry;
-
-	snprintf(buf, PATH_MAX, "%s%s", CACHEMOUNT, path);
-	if (!(dir = opendir(buf)))
-		return;
-
-	while ((entry = xreaddir(dir))) {
-		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
-			continue;
-		// Target file path
-		snprintf(buf2, PATH_MAX, "%s/%s", path, entry->d_name);
-		// Only mount existing file
-		if (access(buf2, F_OK) == -1)
-			continue;
-		if (entry->d_type == DT_DIR) {
-			char *new_path = strdup(buf2);
-			simple_mount(new_path);
-			free(new_path);
-		} else if (entry->d_type == DT_REG) {
-			// Actual file path
-			snprintf(buf, PATH_MAX, "%s/%s", buf, entry->d_name);
-			// Clone all attributes
-			clone_attr(buf2, buf);
-			// Finally, mount the file
-			bind_mount(buf, buf2);
-		}
-	}
-
-	closedir(dir);
-}
-
-/****************
- * Entry points *
- ****************/
-
-static void *start_magisk_hide(void *args) {
-	launch_magiskhide(-1);
-	return NULL;
-}
-
-static void unblock_boot_process() {
-	close(open(UNBLOCKFILE, O_RDONLY | O_CREAT));
-	pthread_exit(NULL);
-}
-
-void post_fs(int client) {
-	// Error handler
-	err_handler = unblock_boot_process;
-
-	// Start log monitor
-	monitor_logs();
-
-	LOGI("** post-fs mode running\n");
-	// ack
-	write_int(client, 0);
-	close(client);
-
-	// Uninstall or core only mode
-	if (access(UNINSTALLER, F_OK) == 0 || access(DISABLEFILE, F_OK) == 0)
-		goto unblock;
-
-	// Allocate buffer
-	buf = xmalloc(PATH_MAX);
-	buf2 = xmalloc(PATH_MAX);
-
-	simple_mount("/system");
-	simple_mount("/vendor");
-
-unblock:
-	unblock_boot_process();
-}
-
-void post_fs_data(int client) {
-	// Error handler
-	err_handler = unblock_boot_process;
-
-	// ack
-	write_int(client, 0);
-	close(client);
-	if (!check_data())
-		goto unblock;
-
-#ifdef DEBUG
-	// Start debug logs in new process
-	debug_log_fd = xopen(DEBUG_LOG, O_WRONLY | O_CREAT | O_CLOEXEC | O_TRUNC, 0644);
-	char *const command[] = { "logcat", "-v", "brief", NULL };
-	debug_log_pid = run_command(0, &debug_log_fd, "/system/bin/logcat", command);
-#endif
-
-	LOGI("** post-fs-data mode running\n");
-
-	// uninstaller
-	if (access(UNINSTALLER, F_OK) == 0) {
-		close(open(UNBLOCKFILE, O_RDONLY | O_CREAT));
-		system("(BOOTMODE=true sh " UNINSTALLER ") &");
-		return;
-	}
-
-	// Allocate buffer
-	if (buf == NULL) buf = xmalloc(PATH_MAX);
-	if (buf2 == NULL) buf2 = xmalloc(PATH_MAX);
-
-	// Cache support
-	if (access("/cache/data_bin", F_OK) == 0) {
-		rm_rf(DATABIN);
-		rename("/cache/data_bin", DATABIN);
-	}
-
-	// Magisk Manual Injector support
-	if (access("/data/local/tmp/magisk", F_OK) == 0) {
-		rm_rf(DATABIN);
-		rename("/data/local/tmp/magisk", DATABIN);
-	}
-
-	// Lazy.... use shell blob
-	system("mv /data/magisk/stock_boot* /data;");
-
-	// Merge images
-	if (merge_img("/cache/magisk.img", MAINIMG))
-		goto unblock;
-	if (merge_img("/data/magisk_merge.img", MAINIMG))
-		goto unblock;
-
-	int new_img = 0;
-
-	if (access(MAINIMG, F_OK) == -1) {
-		if (create_img(MAINIMG, 64))
-			goto unblock;
-		new_img = 1;
-	}
-
-	// Initialize resetprop for the daemon
-	init_resetprop();
-
-	LOGI("* Mounting " MAINIMG "\n");
-	// Mounting magisk image
-	char *magiskloop = mount_image(MAINIMG, MOUNTPOINT);
-	if (magiskloop == NULL)
-		goto unblock;
-
-	if (new_img) {
-		mkdir(COREDIR, 0755);
-		mkdir(COREDIR "/post-fs-data.d", 0755);
-		mkdir(COREDIR "/service.d", 0755);
-		mkdir(COREDIR "/props", 0755);
-	}
-
-	// Run common scripts
-	LOGI("* Running post-fs-data.d scripts\n");
-	exec_common_script("post-fs-data");
-
-	// Core only mode
-	if (access(DISABLEFILE, F_OK) == 0)
-		goto unblock;
-
-	DIR *dir;
-	struct dirent *entry;
-	char *module;
-	struct node_entry *sys_root, *ven_root = NULL, *child;
-
-	dir = xopendir(MOUNTPOINT);
-
-	// Create the system root entry
-	sys_root = xcalloc(sizeof(*sys_root), 1);
-	sys_root->name = strdup("/system");
-
-	int has_modules = 0;
-
-	// Travel through each modules
-	vec_init(&module_list);
-	LOGI("* Loading modules\n");
-	while ((entry = xreaddir(dir))) {
-		if (entry->d_type == DT_DIR) {
-			if (strcmp(entry->d_name, ".") == 0 ||
-				strcmp(entry->d_name, "..") == 0 ||
-				strcmp(entry->d_name, ".core") == 0 ||
-				strcmp(entry->d_name, "lost+found") == 0)
-				continue;
-			snprintf(buf, PATH_MAX, "%s/%s", MOUNTPOINT, entry->d_name);
-			// Check whether remove
-			snprintf(buf2, PATH_MAX, "%s/remove", buf);
-			if (access(buf2, F_OK) == 0) {
-				rm_rf(buf);
-				continue;
-			}
-			// Check whether disable
-			snprintf(buf2, PATH_MAX, "%s/disable", buf);
-			if (access(buf2, F_OK) == 0)
-				continue;
-			// Add the module to list
-			module = strdup(entry->d_name);
-			vec_push_back(&module_list, module);
-			// Read props
-			snprintf(buf2, PATH_MAX, "%s/system.prop", buf);
-			if (access(buf2, F_OK) == 0) {
-				LOGI("%s: loading [system.prop]\n", module);
-				read_prop_file(buf2, 0);
-			}
-			// Check whether enable auto_mount
-			snprintf(buf2, PATH_MAX, "%s/auto_mount", buf);
-			if (access(buf2, F_OK) == -1)
-				continue;
-			// Double check whether the system folder exists
-			snprintf(buf2, PATH_MAX, "%s/system", buf);
-			if (access(buf2, F_OK) == -1)
-				continue;
-
-			// Construct structure
-			has_modules = 1;
-			LOGI("%s: constructing magic mount structure\n", module);
-			construct_tree(module, sys_root);
-		}
-	}
-
-	closedir(dir);
-
-	// Trim image
-	umount_image(MOUNTPOINT, magiskloop);
-	free(magiskloop);
-	trim_img(MAINIMG);
-
-	// Remount them back :)
-	magiskloop = mount_image(MAINIMG, MOUNTPOINT);
-	free(magiskloop);
-
-	if (has_modules) {
-		// Mount mirrors
-		LOGI("* Mounting system/vendor mirrors");
-		int seperate_vendor = 0;
-		struct vector mounts;
-		vec_init(&mounts);
-		file_to_vector("/proc/mounts", &mounts);
-		char *line;
-		vec_for_each(&mounts, line) {
-			if (strstr(line, " /system ")) {
-				sscanf(line, "%s", buf);
-				snprintf(buf2, PATH_MAX, "%s/system", MIRRDIR);
-				xmkdir_p(buf2, 0755);
-				xmount(buf, buf2, "ext4", MS_RDONLY, NULL);
-				LOGI("mount: %s -> %s\n", buf, buf2);
-				continue;
-			}
-			if (strstr(line, " /vendor ")) {
-				seperate_vendor = 1;
-				sscanf(line, "%s", buf);
-				snprintf(buf2, PATH_MAX, "%s/vendor", MIRRDIR);
-				xmkdir_p(buf2, 0755);
-				xmount(buf, buf2, "ext4", MS_RDONLY, NULL);
-				LOGI("mount: %s -> %s\n", buf, buf2);
-				continue;
-			}
-		}
-		vec_deep_destroy(&mounts);
-		if (!seperate_vendor) {
-			snprintf(buf, PATH_MAX, "%s/system/vendor", MIRRDIR);
-			snprintf(buf2, PATH_MAX, "%s/vendor", MIRRDIR);
-			symlink(buf, buf2);
-			LOGI("link: %s -> %s\n", buf, buf2);
-		}
-
-		// Magic!!
-
-		magic_mount(sys_root);
-		// Get the vendor node if exists
-		vec_for_each(sys_root->children, child) {
-			if (strcmp(child->name, "vendor") == 0) {
-				ven_root = child;
-				free(ven_root->name);
-				ven_root->name = strdup("/vendor");
-				ven_root->parent = NULL;
-				break;
-			}
-		}
-		if (ven_root)
-			magic_mount(ven_root);
-	}
-
-	// Cleanup memory
-	destroy_subtree(sys_root);
-
-	// Execute module scripts
-	LOGI("* Running module post-fs-data scripts\n");
-	exec_module_script("post-fs-data");
-
-	// Systemless hosts
-	if (access(HOSTSFILE, F_OK) == 0) {
-		LOGI("* Enabling systemless hosts file support");
-		bind_mount(HOSTSFILE, "/system/etc/hosts");
-	}
-
-	// Start magiskhide if enabled
-	char *hide_prop = getprop(MAGISKHIDE_PROP);
-	if (hide_prop) {
-		if (strcmp(hide_prop, "1") == 0) {
-			pthread_t thread;
-			xpthread_create(&thread, NULL, start_magisk_hide, NULL);
-			pthread_detach(thread);
-		}
-		free(hide_prop);
-	}
-
-unblock:
-	unblock_boot_process();
-}
-
-void late_start(int client) {
-	LOGI("** late_start service mode running\n");
-	// ack
-	write_int(client, 0);
-	close(client);
-
-	// Allocate buffer
-	if (buf == NULL) buf = xmalloc(PATH_MAX);
-	if (buf2 == NULL) buf2 = xmalloc(PATH_MAX);
-
-	// Wait till the full patch is done
-	pthread_join(sepol_patch, NULL);
-
-	// Run scripts after full patch, most reliable way to run scripts
-	LOGI("* Running service.d scripts\n");
-	exec_common_script("service");
-	LOGI("* Running module service scripts\n");
-	exec_module_script("service");
-
-	// Install Magisk Manager if exists
-	if (access(MANAGERAPK, F_OK) == 0) {
-		while(1) {
-			sleep(5);
-			char *const command[] = { "sh", "-c", 
-				"CLASSPATH=/system/framework/pm.jar "
-				"/system/bin/app_process /system/bin "
-				"com.android.commands.pm.Pm install -r " MANAGERAPK, NULL };
-			int apk_res = 0, pid;
-			pid = run_command(1, &apk_res, "/system/bin/sh", command);
-			waitpid(pid, NULL, 0);
-			fdgets(buf, PATH_MAX, apk_res);
-			close(apk_res);
-			// Keep trying until pm is started
-			if (strstr(buf, "Error:") == NULL)
-				break;
-		}
-		unlink(MANAGERAPK);
-	}
-
-	// All boot stage done, cleanup everything
-	free(buf);
-	free(buf2);
-	vec_deep_destroy(&module_list);
-
-#ifdef DEBUG
-	// Stop recording the boot logcat after every boot task is done
-	extern int debug_log_pid, debug_log_fd;
-	kill(debug_log_pid, SIGTERM);
-	waitpid(debug_log_pid, NULL, 0);
-	close(debug_log_fd);
-#endif
-}

jni/daemon/daemon.c

@@ -1,208 +0,0 @@
-/* daemon.c - Magisk Daemon
- *
- * Start the daemon and wait for requests
- * Connect the daemon and send requests through sockets
- */
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <string.h>
-#include <errno.h>
-#include <pthread.h>
-#include <sys/un.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-#include <selinux/selinux.h>
-
-#include "magisk.h"
-#include "utils.h"
-#include "daemon.h"
-#include "magiskpolicy.h"
-
-pthread_t sepol_patch;
-int null_fd;
-
-static void *request_handler(void *args) {
-	// Setup the default error handler for threads
-	err_handler = exit_thread;
-
-	int client = *((int *) args);
-	free(args);
-	client_request req = read_int(client);
-
-	struct ucred credentials;
-	get_client_cred(client, &credentials);
-
-	switch (req) {
-	case LAUNCH_MAGISKHIDE:
-	case STOP_MAGISKHIDE:
-	case ADD_HIDELIST:
-	case RM_HIDELIST:
-	case POST_FS:
-	case POST_FS_DATA:
-	case LATE_START:
-		if (credentials.uid != 0) {
-			write_int(client, ROOT_REQUIRED);
-			close(client);
-			return NULL;
-		}
-	default:
-		break;
-	}
-
-	switch (req) {
-	case LAUNCH_MAGISKHIDE:
-		launch_magiskhide(client);
-		break;
-	case STOP_MAGISKHIDE:
-		stop_magiskhide(client);
-		break;
-	case ADD_HIDELIST:
-		add_hide_list(client);
-		break;
-	case RM_HIDELIST:
-		rm_hide_list(client);
-		break;
-	case SUPERUSER:
-		su_daemon_receiver(client);
-		break;
-	case CHECK_VERSION:
-		write_string(client, MAGISK_VER_STR);
-		close(client);
-		break;
-	case CHECK_VERSION_CODE:
-		write_int(client, MAGISK_VER_CODE);
-		close(client);
-		break;
-	case POST_FS:
-		post_fs(client);
-		break;
-	case POST_FS_DATA:
-		post_fs_data(client);
-		break;
-	case LATE_START:
-		late_start(client);
-		break;
-	default:
-		break;
-	}
-	// Just in case
-	close(client);
-	return NULL;
-}
-
-/* Setup the address and return socket fd */
-static int setup_socket(struct sockaddr_un *sun) {
-	int fd = xsocket(AF_LOCAL, SOCK_STREAM, 0);
-	if (fcntl(fd, F_SETFD, FD_CLOEXEC))
-		PLOGE("fcntl FD_CLOEXEC");
-
-	memset(sun, 0, sizeof(*sun));
-	sun->sun_family = AF_LOCAL;
-	memcpy(sun->sun_path, REQUESTOR_DAEMON_PATH, REQUESTOR_DAEMON_PATH_LEN);
-	return fd;
-}
-
-static void *large_sepol_patch(void *args) {
-	LOGD("sepol: Starting large patch thread\n");
-	// Patch su to everything
-	sepol_allow("su", ALL, ALL, ALL);
-	dump_policydb(SELINUX_LOAD);
-	LOGD("sepol: Large patch done\n");
-	destroy_policydb();
-	return NULL;
-}
-
-void start_daemon(int client) {
-	// Launch the daemon, create new session, set proper context
-	if (getuid() != UID_ROOT || getgid() != UID_ROOT) {
-		fprintf(stderr, "Starting daemon requires root: %s\n", strerror(errno));
-		PLOGE("start daemon");
-	}
-
-	switch (fork()) {
-	case -1:
-		PLOGE("fork");
-	case 0:
-		break;
-	default:
-		return;
-	}
-
-	// First close the client, it's useless for us
-	close(client);
-	xsetsid();
-	setcon("u:r:su:s0");
-	umask(022);
-	null_fd = xopen("/dev/null", O_RDWR | O_CLOEXEC);
-	xdup2(null_fd, STDIN_FILENO);
-	xdup2(null_fd, STDOUT_FILENO);
-	xdup2(null_fd, STDERR_FILENO);
-
-	// Patch selinux with medium patch before we do anything
-	load_policydb(SELINUX_POLICY);
-	sepol_med_rules();
-	dump_policydb(SELINUX_LOAD);
-
-	// Continue the larger patch in another thread, we will join later
-	pthread_create(&sepol_patch, NULL, large_sepol_patch, NULL);
-
-	struct sockaddr_un sun;
-	int fd = setup_socket(&sun);
-
-	xbind(fd, (struct sockaddr*) &sun, sizeof(sun));
-	xlisten(fd, 10);
-
-	// Change process name
-	strcpy(argv0, "magisk_daemon");
-	// The root daemon should not do anything if an error occurs
-	// It should stay intact under any circumstances
-	err_handler = do_nothing;
-
-	LOGI("Magisk v" xstr(MAGISK_VERSION) " daemon started\n");
-
-	// Unlock all blocks for rw
-	unlock_blocks();
-
-	// Setup links under /sbin
-	xmount(NULL, "/", NULL, MS_REMOUNT, NULL);
-	create_links(NULL, "/sbin");
-	xchmod("/sbin", 0755);
-	mkdir("/magisk", 0755);
-	xchmod("/magisk", 0755);
-	xmount(NULL, "/", NULL, MS_REMOUNT | MS_RDONLY, NULL);
-
-	// Loop forever to listen for requests
-	while(1) {
-		int *client = xmalloc(sizeof(int));
-		*client = xaccept(fd, NULL, NULL);
-		// Just in case, set to close on exec
-		fcntl(*client, F_SETFD, FD_CLOEXEC);
-		pthread_t thread;
-		xpthread_create(&thread, NULL, request_handler, client);
-		// Detach the thread, we will never join it
-		pthread_detach(thread);
-	}
-}
-
-/* Connect the daemon, and return a socketfd */
-int connect_daemon() {
-	struct sockaddr_un sun;
-	int fd = setup_socket(&sun);
-	// LOGD("client: trying to connect socket\n");
-	if (connect(fd, (struct sockaddr*) &sun, sizeof(sun))) {
-		/* If we cannot access the daemon, we start the daemon
-		 * since there is no clear entry point when the daemon should be started
-		 */
-		LOGD("client: connect fail, try launching new daemon process\n");
-		start_daemon(fd);
-		do {
-			// Wait for 10ms
-			usleep(10);
-		} while (connect(fd, (struct sockaddr*) &sun, sizeof(sun)));
-	}
-	return fd;
-}

jni/daemon/log_monitor.c

@@ -1,46 +0,0 @@
-/* log_monitor.c - New thread to monitor logcat
- *
- * Open a new thread to call logcat and get logs with tag "Magisk"
- * Also, write the logs to a log file for debugging purpose
- *
- */
-
-#include <stdio.h>
-#include <limits.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <sys/wait.h>
-
-#include "magisk.h"
-#include "utils.h"
-#include "daemon.h"
-
-static void *logger_thread(void *args) {
-	// Setup error handler
-	err_handler = exit_thread;
-
-	rename(LOGFILE, LASTLOG);
-	int log_fd, log_pid;
-
-	log_fd = xopen(LOGFILE, O_WRONLY | O_CREAT | O_CLOEXEC | O_TRUNC, 0644);
-
-	while (1) {
-		// Start logcat
-		char *const command[] = { "logcat", "-s", "Magisk", "-v", "thread", NULL };
-		log_pid = run_command(0, &log_fd, "/system/bin/logcat", command);
-		waitpid(log_pid, NULL, 0);
-		// For some reason it went here, clear buffer and restart
-		system("logcat -c");
-	}
-
-	// Should never be here, but well...
-	close(log_fd);
-	return NULL;
-}
-
-/* Start a new thread to monitor logcat and dump to logfile */
-void monitor_logs() {
-	pthread_t thread;
-	xpthread_create(&thread, NULL, logger_thread, NULL);
-	pthread_detach(thread);
-}

jni/daemon/socket_trans.c

@@ -1,148 +0,0 @@
-/* socket_trans.c - Functions to transfer data through socket
- */
-
-#include <unistd.h>
-#include <string.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#include "magisk.h"
-#include "utils.h"
-#include "daemon.h"
-
-/*
- * Receive a file descriptor from a Unix socket.
- * Contributed by @mkasick
- *
- * Returns the file descriptor on success, or -1 if a file
- * descriptor was not actually included in the message
- *
- * On error the function terminates by calling exit(-1)
- */
-int recv_fd(int sockfd) {
-    // Need to receive data from the message, otherwise don't care about it.
-    char iovbuf;
-
-    struct iovec iov = {
-        .iov_base = &iovbuf,
-        .iov_len  = 1,
-    };
-
-    char cmsgbuf[CMSG_SPACE(sizeof(int))];
-
-    struct msghdr msg = {
-        .msg_iov        = &iov,
-        .msg_iovlen     = 1,
-        .msg_control    = cmsgbuf,
-        .msg_controllen = sizeof(cmsgbuf),
-    };
-
-    xrecvmsg(sockfd, &msg, MSG_WAITALL);
-
-    // Was a control message actually sent?
-    switch (msg.msg_controllen) {
-    case 0:
-        // No, so the file descriptor was closed and won't be used.
-        return -1;
-    case sizeof(cmsgbuf):
-        // Yes, grab the file descriptor from it.
-        break;
-    default:
-        goto error;
-    }
-
-    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
-
-    if (cmsg             == NULL                  ||
-        cmsg->cmsg_len   != CMSG_LEN(sizeof(int)) ||
-        cmsg->cmsg_level != SOL_SOCKET            ||
-        cmsg->cmsg_type  != SCM_RIGHTS) {
-error:
-        LOGE("unable to read fd");
-        exit(-1);
-    }
-
-    return *(int *)CMSG_DATA(cmsg);
-}
-
-/*
- * Send a file descriptor through a Unix socket.
- * Contributed by @mkasick
- *
- * On error the function terminates by calling exit(-1)
- *
- * fd may be -1, in which case the dummy data is sent,
- * but no control message with the FD is sent.
- */
-void send_fd(int sockfd, int fd) {
-    // Need to send some data in the message, this will do.
-    struct iovec iov = {
-        .iov_base = "",
-        .iov_len  = 1,
-    };
-
-    struct msghdr msg = {
-        .msg_iov        = &iov,
-        .msg_iovlen     = 1,
-    };
-
-    char cmsgbuf[CMSG_SPACE(sizeof(int))];
-
-    if (fd != -1) {
-        // Is the file descriptor actually open?
-        if (fcntl(fd, F_GETFD) == -1) {
-            if (errno != EBADF) {
-                PLOGE("unable to send fd");
-            }
-            // It's closed, don't send a control message or sendmsg will EBADF.
-        } else {
-            // It's open, send the file descriptor in a control message.
-            msg.msg_control    = cmsgbuf;
-            msg.msg_controllen = sizeof(cmsgbuf);
-
-            struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
-
-            cmsg->cmsg_len   = CMSG_LEN(sizeof(int));
-            cmsg->cmsg_level = SOL_SOCKET;
-            cmsg->cmsg_type  = SCM_RIGHTS;
-
-            *(int *)CMSG_DATA(cmsg) = fd;
-        }
-    }
-
-    xsendmsg(sockfd, &msg, 0);
-}
-
-int read_int(int fd) {
-    int val;
-    xxread(fd, &val, sizeof(int));
-    return val;
-}
-
-void write_int(int fd, int val) {
-    if (fd < 0) return;
-    xwrite(fd, &val, sizeof(int));
-}
-
-char* read_string(int fd) {
-    int len = read_int(fd);
-    if (len > PATH_MAX || len < 0) {
-        LOGE("invalid string length %d", len);
-        exit(1);
-    }
-    char* val = xmalloc(sizeof(char) * (len + 1));
-    xxread(fd, val, len);
-    val[len] = '\0';
-    return val;
-}
-
-void write_string(int fd, const char* val) {
-    if (fd < 0) return;
-    int len = strlen(val);
-    write_int(fd, len);
-    xwrite(fd, val, len);
-}

jni/external/Android.mk

@@ -0,0 +1,157 @@
+LOCAL_PATH:= $(call my-dir)
+
+# libsqlite.so (stub)
+include $(CLEAR_VARS)
+LOCAL_MODULE:= libsqlite
+LOCAL_SRC_FILES := stubs/sqlite3_stub.c
+include $(BUILD_SHARED_LIBRARY)
+
+# libselinux.so (stub)
+include $(CLEAR_VARS)
+LOCAL_MODULE:= libselinux
+LOCAL_C_INCLUDES := $(LIBSELINUX)
+LOCAL_SRC_FILES := stubs/selinux_stub.c
+include $(BUILD_SHARED_LIBRARY)
+
+# libfdt.a
+include $(CLEAR_VARS)
+LOCAL_MODULE:= libfdt
+LOCAL_C_INCLUDES := $(LIBFDT)
+LOCAL_SRC_FILES := \
+	dtc/libfdt/fdt.c \
+	dtc/libfdt/fdt_addresses.c \
+	dtc/libfdt/fdt_empty_tree.c \
+	dtc/libfdt/fdt_overlay.c \
+	dtc/libfdt/fdt_ro.c \
+	dtc/libfdt/fdt_rw.c \
+	dtc/libfdt/fdt_strerror.c \
+	dtc/libfdt/fdt_sw.c \
+	dtc/libfdt/fdt_wip.c
+include $(BUILD_STATIC_LIBRARY)
+
+# liblz4.a
+include $(CLEAR_VARS)
+LOCAL_MODULE := liblz4
+LOCAL_C_INCLUDES += $(LIBLZ4)
+LOCAL_SRC_FILES := \
+	lz4/lib/lz4.c \
+	lz4/lib/lz4frame.c \
+	lz4/lib/lz4hc.c \
+	lz4/lib/xxhash.c
+include $(BUILD_STATIC_LIBRARY)
+
+# libbz2.a
+include $(CLEAR_VARS)
+LOCAL_MODULE := libbz2
+LOCAL_C_INCLUDES += $(LIBBZ2)
+LOCAL_SRC_FILES := \
+	bzip2/blocksort.c  \
+	bzip2/huffman.c    \
+	bzip2/crctable.c   \
+	bzip2/randtable.c  \
+	bzip2/compress.c   \
+	bzip2/decompress.c \
+	bzip2/bzlib.c
+include $(BUILD_STATIC_LIBRARY)
+
+# liblzma.a
+include $(CLEAR_VARS)
+LOCAL_MODULE := liblzma
+LOCAL_C_INCLUDES += \
+	$(EXT_PATH)/xz_config \
+	$(EXT_PATH)/xz/src/common \
+	$(EXT_PATH)/xz/src/liblzma/api \
+	$(EXT_PATH)/xz/src/liblzma/check \
+	$(EXT_PATH)/xz/src/liblzma/common \
+	$(EXT_PATH)/xz/src/liblzma/delta \
+	$(EXT_PATH)/xz/src/liblzma/lz \
+	$(EXT_PATH)/xz/src/liblzma/lzma \
+	$(EXT_PATH)/xz/src/liblzma/rangecoder \
+	$(EXT_PATH)/xz/src/liblzma/simple \
+	$(EXT_PATH)/xz/src/liblzma
+LOCAL_SRC_FILES := \
+	xz/src/common/tuklib_cpucores.c \
+	xz/src/common/tuklib_exit.c \
+	xz/src/common/tuklib_mbstr_fw.c \
+	xz/src/common/tuklib_mbstr_width.c \
+	xz/src/common/tuklib_open_stdxxx.c \
+	xz/src/common/tuklib_physmem.c \
+	xz/src/common/tuklib_progname.c \
+	xz/src/liblzma/check/check.c \
+	xz/src/liblzma/check/crc32_fast.c \
+	xz/src/liblzma/check/crc32_table.c \
+	xz/src/liblzma/check/crc64_fast.c \
+	xz/src/liblzma/check/crc64_table.c \
+	xz/src/liblzma/check/sha256.c \
+	xz/src/liblzma/common/alone_decoder.c \
+	xz/src/liblzma/common/alone_encoder.c \
+	xz/src/liblzma/common/auto_decoder.c \
+	xz/src/liblzma/common/block_buffer_decoder.c \
+	xz/src/liblzma/common/block_buffer_encoder.c \
+	xz/src/liblzma/common/block_decoder.c \
+	xz/src/liblzma/common/block_encoder.c \
+	xz/src/liblzma/common/block_header_decoder.c \
+	xz/src/liblzma/common/block_header_encoder.c \
+	xz/src/liblzma/common/block_util.c \
+	xz/src/liblzma/common/common.c \
+	xz/src/liblzma/common/easy_buffer_encoder.c \
+	xz/src/liblzma/common/easy_decoder_memusage.c \
+	xz/src/liblzma/common/easy_encoder.c \
+	xz/src/liblzma/common/easy_encoder_memusage.c \
+	xz/src/liblzma/common/easy_preset.c \
+	xz/src/liblzma/common/filter_buffer_decoder.c \
+	xz/src/liblzma/common/filter_buffer_encoder.c \
+	xz/src/liblzma/common/filter_common.c \
+	xz/src/liblzma/common/filter_decoder.c \
+	xz/src/liblzma/common/filter_encoder.c \
+	xz/src/liblzma/common/filter_flags_decoder.c \
+	xz/src/liblzma/common/filter_flags_encoder.c \
+	xz/src/liblzma/common/hardware_cputhreads.c \
+	xz/src/liblzma/common/hardware_physmem.c \
+	xz/src/liblzma/common/index.c \
+	xz/src/liblzma/common/index_decoder.c \
+	xz/src/liblzma/common/index_encoder.c \
+	xz/src/liblzma/common/index_hash.c \
+	xz/src/liblzma/common/outqueue.c \
+	xz/src/liblzma/common/stream_buffer_decoder.c \
+	xz/src/liblzma/common/stream_buffer_encoder.c \
+	xz/src/liblzma/common/stream_decoder.c \
+	xz/src/liblzma/common/stream_encoder.c \
+	xz/src/liblzma/common/stream_encoder_mt.c \
+	xz/src/liblzma/common/stream_flags_common.c \
+	xz/src/liblzma/common/stream_flags_decoder.c \
+	xz/src/liblzma/common/stream_flags_encoder.c \
+	xz/src/liblzma/common/vli_decoder.c \
+	xz/src/liblzma/common/vli_encoder.c \
+	xz/src/liblzma/common/vli_size.c \
+	xz/src/liblzma/delta/delta_common.c \
+	xz/src/liblzma/delta/delta_decoder.c \
+	xz/src/liblzma/delta/delta_encoder.c \
+	xz/src/liblzma/lz/lz_decoder.c \
+	xz/src/liblzma/lz/lz_encoder.c \
+	xz/src/liblzma/lz/lz_encoder_mf.c \
+	xz/src/liblzma/lzma/fastpos_table.c \
+	xz/src/liblzma/lzma/fastpos_tablegen.c \
+	xz/src/liblzma/lzma/lzma2_decoder.c \
+	xz/src/liblzma/lzma/lzma2_encoder.c \
+	xz/src/liblzma/lzma/lzma_decoder.c \
+	xz/src/liblzma/lzma/lzma_encoder.c \
+	xz/src/liblzma/lzma/lzma_encoder_optimum_fast.c \
+	xz/src/liblzma/lzma/lzma_encoder_optimum_normal.c \
+	xz/src/liblzma/lzma/lzma_encoder_presets.c \
+	xz/src/liblzma/rangecoder/price_table.c \
+	xz/src/liblzma/rangecoder/price_tablegen.c \
+	xz/src/liblzma/simple/arm.c \
+	xz/src/liblzma/simple/armthumb.c \
+	xz/src/liblzma/simple/ia64.c \
+	xz/src/liblzma/simple/powerpc.c \
+	xz/src/liblzma/simple/simple_coder.c \
+	xz/src/liblzma/simple/simple_decoder.c \
+	xz/src/liblzma/simple/simple_encoder.c \
+	xz/src/liblzma/simple/sparc.c \
+	xz/src/liblzma/simple/x86.c
+LOCAL_CFLAGS += -DHAVE_CONFIG_H -std=c99
+include $(BUILD_STATIC_LIBRARY)
+
+# libsepol.a
+include $(SE_PATH)/libsepol/Android.mk

jni/external/stubs/selinux_stub.c

@@ -0,0 +1,356 @@
+#include <stdbool.h>
+#include <selinux/avc.h>
+#include <selinux/context.h>
+#include <selinux/get_context_list.h>
+#include <selinux/get_default_type.h>
+#include <selinux/label.h>
+#include <selinux/restorecon.h>
+#include <selinux/selinux.h>
+int is_selinux_enabled(void) { return 0; }
+int is_selinux_mls_enabled(void) { return 0; }
+void freecon(char * con) { }
+void freeconary(char ** con) { }
+int getcon(char ** con) { return 0; }
+int getcon_raw(char ** con) { return 0; }
+int setcon(const char * con) { return 0; }
+int setcon_raw(const char * con) { return 0; }
+int getpidcon(pid_t pid, char ** con) { return 0; }
+int getpidcon_raw(pid_t pid, char ** con) { return 0; }
+int getprevcon(char ** con) { return 0; }
+int getprevcon_raw(char ** con) { return 0; }
+int getexeccon(char ** con) { return 0; }
+int getexeccon_raw(char ** con) { return 0; }
+int setexeccon(const char * con) { return 0; }
+int setexeccon_raw(const char * con) { return 0; }
+int getfscreatecon(char ** con) { return 0; }
+int getfscreatecon_raw(char ** con) { return 0; }
+int setfscreatecon(const char * context) { return 0; }
+int setfscreatecon_raw(const char * context) { return 0; }
+int getkeycreatecon(char ** con) { return 0; }
+int getkeycreatecon_raw(char ** con) { return 0; }
+int setkeycreatecon(const char * context) { return 0; }
+int setkeycreatecon_raw(const char * context) { return 0; }
+int getsockcreatecon(char ** con) { return 0; }
+int getsockcreatecon_raw(char ** con) { return 0; }
+int setsockcreatecon(const char * context) { return 0; }
+int setsockcreatecon_raw(const char * context) { return 0; }
+int getfilecon(const char *path, char ** con) { return 0; }
+int getfilecon_raw(const char *path, char ** con) { return 0; }
+int lgetfilecon(const char *path, char ** con) { return 0; }
+int lgetfilecon_raw(const char *path, char ** con) { return 0; }
+int fgetfilecon(int fd, char ** con) { return 0; }
+int fgetfilecon_raw(int fd, char ** con) { return 0; }
+int setfilecon(const char *path, const char * con) { return 0; }
+int setfilecon_raw(const char *path, const char * con) { return 0; }
+int lsetfilecon(const char *path, const char * con) { return 0; }
+int lsetfilecon_raw(const char *path, const char * con) { return 0; }
+int fsetfilecon(int fd, const char * con) { return 0; }
+int fsetfilecon_raw(int fd, const char * con) { return 0; }
+int getpeercon(int fd, char ** con) { return 0; }
+int getpeercon_raw(int fd, char ** con) { return 0; }
+void selinux_set_callback(int type, union selinux_callback cb) { }
+int security_compute_av(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					access_vector_t requested,
+					struct av_decision *avd) { return 0; }
+int security_compute_av_raw(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					access_vector_t requested,
+					struct av_decision *avd) { return 0; }
+int security_compute_av_flags(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					access_vector_t requested,
+					struct av_decision *avd) { return 0; }
+int security_compute_av_flags_raw(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					access_vector_t requested,
+					struct av_decision *avd) { return 0; }
+int security_compute_create(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					char ** newcon) { return 0; }
+int security_compute_create_raw(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					char ** newcon) { return 0; }
+int security_compute_create_name(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					const char *objname,
+					char ** newcon) { return 0; }
+int security_compute_create_name_raw(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					const char *objname,
+					char ** newcon) { return 0; }
+int security_compute_relabel(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					char ** newcon) { return 0; }
+int security_compute_relabel_raw(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					char ** newcon) { return 0; }
+int security_compute_member(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					char ** newcon) { return 0; }
+int security_compute_member_raw(const char * scon,
+					const char * tcon,
+					security_class_t tclass,
+					char ** newcon) { return 0; }
+int security_compute_user(const char * scon,
+				const char *username,
+				char *** con) { return 0; }
+int security_compute_user_raw(const char * scon,
+				const char *username,
+				char *** con) { return 0; }
+int security_load_policy(void *data, size_t len) { return 0; }
+int security_get_initial_context(const char *name,
+					char ** con) { return 0; }
+int security_get_initial_context_raw(const char *name,
+						char ** con) { return 0; }
+int selinux_mkload_policy(int preservebools) { return 0; }
+int selinux_init_load_policy(int *enforce) { return 0; }
+int security_set_boolean_list(size_t boolcnt,
+					SELboolean * boollist, int permanent) { return 0; }
+int security_load_booleans(char *path) { return 0; }
+int security_check_context(const char * con) { return 0; }
+int security_check_context_raw(const char * con) { return 0; }
+int security_canonicalize_context(const char * con,
+					char ** canoncon) { return 0; }
+int security_canonicalize_context_raw(const char * con,
+						char ** canoncon) { return 0; }
+int security_getenforce(void) { return 0; }
+int security_setenforce(int value) { return 0; }
+int security_deny_unknown(void) { return 0; }
+int security_disable(void) { return 0; }
+int security_policyvers(void) { return 0; }
+int security_get_boolean_names(char ***names, int *len) { return 0; }
+int security_get_boolean_pending(const char *name) { return 0; }
+int security_get_boolean_active(const char *name) { return 0; }
+int security_set_boolean(const char *name, int value) { return 0; }
+int security_commit_booleans(void) { return 0; }
+int selinux_set_mapping(struct security_class_mapping *map) { return 0; }
+security_class_t mode_to_security_class(mode_t mode) { return 0; }
+security_class_t string_to_security_class(const char *name) { return 0; }
+const char *security_class_to_string(security_class_t cls) { return 0; }
+const char *security_av_perm_to_string(security_class_t tclass,
+						access_vector_t perm) { return 0; }
+access_vector_t string_to_av_perm(security_class_t tclass,
+					const char *name) { return 0; }
+int security_av_string(security_class_t tclass,
+				access_vector_t av, char **result) { return 0; }
+void print_access_vector(security_class_t tclass, access_vector_t av) { }
+void set_matchpathcon_printf(void (*f) (const char *fmt, ...)) { }
+void set_matchpathcon_invalidcon(int (*f) (const char *path,
+						unsigned lineno,
+						char *context)) { }
+void set_matchpathcon_canoncon(int (*f) (const char *path,
+						unsigned lineno,
+						char **context)) { }
+void set_matchpathcon_flags(unsigned int flags) { }
+int matchpathcon_init(const char *path) { return 0; }
+int matchpathcon_init_prefix(const char *path, const char *prefix) { return 0; }
+void matchpathcon_fini(void) { }
+int realpath_not_final(const char *name, char *resolved_path) { return 0; }
+int matchpathcon(const char *path,
+			mode_t mode, char ** con) { return 0; }
+int matchpathcon_index(const char *path,
+				  mode_t mode, char ** con) { return 0; }
+int matchpathcon_filespec_add(ino_t ino, int specind, const char *file) { return 0; }
+void matchpathcon_filespec_destroy(void) { }
+void matchpathcon_filespec_eval(void) { }
+void matchpathcon_checkmatches(char *str) { }
+int matchmediacon(const char *media, char ** con) { return 0; }
+int selinux_getenforcemode(int *enforce) { return 0; }
+char *selinux_boolean_sub(const char *boolean_name) { return 0; }
+int selinux_getpolicytype(char **policytype) { return 0; }
+const char *selinux_policy_root(void) { return 0; }
+int selinux_set_policy_root(const char *rootpath) { return 0; }
+const char *selinux_current_policy_path(void) { return 0; }
+const char *selinux_binary_policy_path(void) { return 0; }
+const char *selinux_failsafe_context_path(void) { return 0; }
+const char *selinux_removable_context_path(void) { return 0; }
+const char *selinux_default_context_path(void) { return 0; }
+const char *selinux_user_contexts_path(void) { return 0; }
+const char *selinux_file_context_path(void) { return 0; }
+const char *selinux_file_context_homedir_path(void) { return 0; }
+const char *selinux_file_context_local_path(void) { return 0; }
+const char *selinux_file_context_subs_path(void) { return 0; }
+const char *selinux_file_context_subs_dist_path(void) { return 0; }
+const char *selinux_homedir_context_path(void) { return 0; }
+const char *selinux_media_context_path(void) { return 0; }
+const char *selinux_virtual_domain_context_path(void) { return 0; }
+const char *selinux_virtual_image_context_path(void) { return 0; }
+const char *selinux_lxc_contexts_path(void) { return 0; }
+const char *selinux_x_context_path(void) { return 0; }
+const char *selinux_sepgsql_context_path(void) { return 0; }
+const char *selinux_openrc_contexts_path(void) { return 0; }
+const char *selinux_openssh_contexts_path(void) { return 0; }
+const char *selinux_snapperd_contexts_path(void) { return 0; }
+const char *selinux_systemd_contexts_path(void) { return 0; }
+const char *selinux_contexts_path(void) { return 0; }
+const char *selinux_securetty_types_path(void) { return 0; }
+const char *selinux_booleans_subs_path(void) { return 0; }
+const char *selinux_booleans_path(void) { return 0; }
+const char *selinux_customizable_types_path(void) { return 0; }
+const char *selinux_users_path(void) { return 0; }
+const char *selinux_usersconf_path(void) { return 0; }
+const char *selinux_translations_path(void) { return 0; }
+const char *selinux_colors_path(void) { return 0; }
+const char *selinux_netfilter_context_path(void) { return 0; }
+const char *selinux_path(void) { return 0; }
+int selinux_check_access(const char * scon, const char * tcon, const char *tclass, const char *perm, void *auditdata) { return 0; }
+int selinux_check_passwd_access(access_vector_t requested) { return 0; }
+int checkPasswdAccess(access_vector_t requested) { return 0; }
+int selinux_check_securetty_context(const char * tty_context) { return 0; }
+void set_selinuxmnt(const char *mnt) { }
+int selinuxfs_exists(void) { return 0; }
+void fini_selinuxmnt(void) {}
+int setexecfilecon(const char *filename, const char *fallback_type) { return 0; }
+#ifndef DISABLE_RPM
+int rpm_execcon(unsigned int verified,
+			const char *filename,
+			char *const argv[], char *const envp[]) { return 0; }
+#endif
+int is_context_customizable(const char * scontext) { return 0; }
+int selinux_trans_to_raw_context(const char * trans,
+					char ** rawp) { return 0; }
+int selinux_raw_to_trans_context(const char * raw,
+					char ** transp) { return 0; }
+int selinux_raw_context_to_color(const char * raw,
+					char **color_str) { return 0; }
+int getseuserbyname(const char *linuxuser, char **seuser, char **level) { return 0; }
+int getseuser(const char *username, const char *service,
+			char **r_seuser, char **r_level) { return 0; }
+int selinux_file_context_cmp(const char * a,
+				const char * b) { return 0; }
+int selinux_file_context_verify(const char *path, mode_t mode) { return 0; }
+int selinux_lsetfilecon_default(const char *path) { return 0; }
+void selinux_reset_config(void) { }
+int avc_sid_to_context(security_id_t sid, char ** ctx) { return 0; }
+int avc_sid_to_context_raw(security_id_t sid, char ** ctx) { return 0; }
+int avc_context_to_sid(const char * ctx, security_id_t * sid) { return 0; }
+int avc_context_to_sid_raw(const char * ctx, security_id_t * sid) { return 0; }
+int sidget(security_id_t sid) { return 0; }
+int sidput(security_id_t sid) { return 0; }
+int avc_get_initial_sid(const char *name, security_id_t * sid) { return 0; }
+int avc_init(const char *msgprefix,
+		const struct avc_memory_callback *mem_callbacks,
+		const struct avc_log_callback *log_callbacks,
+		const struct avc_thread_callback *thread_callbacks,
+		const struct avc_lock_callback *lock_callbacks) { return 0; }
+int avc_open(struct selinux_opt *opts, unsigned nopts) { return 0; }
+void avc_cleanup(void) { }
+int avc_reset(void) { return 0; }
+void avc_destroy(void) { }
+int avc_has_perm_noaudit(security_id_t ssid,
+			security_id_t tsid,
+			security_class_t tclass,
+			access_vector_t requested,
+			struct avc_entry_ref *aeref, struct av_decision *avd) { return 0; }
+int avc_has_perm(security_id_t ssid, security_id_t tsid,
+			security_class_t tclass, access_vector_t requested,
+			struct avc_entry_ref *aeref, void *auditdata) { return 0; }
+void avc_audit(security_id_t ssid, security_id_t tsid,
+			security_class_t tclass, access_vector_t requested,
+			struct av_decision *avd, int result, void *auditdata) { }
+int avc_compute_create(security_id_t ssid,
+			security_id_t tsid,
+			security_class_t tclass, security_id_t * newsid) { return 0; }
+int avc_compute_member(security_id_t ssid,
+			security_id_t tsid,
+			security_class_t tclass, security_id_t * newsid) { return 0; }
+int avc_add_callback(int (*callback)
+			(uint32_t event, security_id_t ssid,
+			security_id_t tsid, security_class_t tclass,
+			access_vector_t perms,
+			access_vector_t * out_retained),
+			uint32_t events, security_id_t ssid,
+			security_id_t tsid, security_class_t tclass,
+			access_vector_t perms) { return 0; }
+void avc_cache_stats(struct avc_cache_stats *stats) { }
+void avc_av_stats(void) { }
+void avc_sid_stats(void) { }
+int avc_netlink_open(int blocking) { return 0; }
+void avc_netlink_loop(void) { }
+void avc_netlink_close(void) { }
+int avc_netlink_acquire_fd(void) { return 0; }
+void avc_netlink_release_fd(void) { }
+int avc_netlink_check_nb(void) { return 0; }
+int selinux_status_open(int fallback) { return 0; }
+void selinux_status_close(void) { }
+int selinux_status_updated(void) { return 0; }
+int selinux_status_getenforce(void) { return 0; }
+int selinux_status_policyload(void) { return 0; }
+int selinux_status_deny_unknown(void) { return 0; }
+context_t context_new(const char *s) { return 0; }
+char *context_str(context_t c) { return 0; }
+void context_free(context_t c) { }
+const char *context_type_get(context_t c) { return 0; }
+const char *context_range_get(context_t c) { return 0; }
+const char *context_role_get(context_t c) { return 0; }
+const char *context_user_get(context_t c) { return 0; }
+int context_type_set(context_t c, const char *s) { return 0; }
+int context_range_set(context_t c, const char *s) { return 0; }
+int context_role_set(context_t c, const char *s) { return 0; }
+int context_user_set(context_t c, const char *s) { return 0; }
+int get_ordered_context_list(const char *user,
+					char * fromcon,
+					char *** list) { return 0; }
+int get_ordered_context_list_with_level(const char *user,
+					const char *level,
+					char * fromcon,
+					char *** list) { return 0; }
+int get_default_context(const char *user,
+					char * fromcon,
+					char ** newcon) { return 0; }
+int get_default_context_with_level(const char *user,
+					const char *level,
+					char * fromcon,
+					char ** newcon) { return 0; }
+int get_default_context_with_role(const char *user,
+					const char *role,
+					char * fromcon,
+					char ** newcon) { return 0; }
+int get_default_context_with_rolelevel(const char *user,
+					const char *role,
+					const char *level,
+					char * fromcon,
+					char ** newcon) { return 0; }
+int query_user_context(char ** list,
+				  char ** newcon) { return 0; }
+int manual_user_enter_context(const char *user,
+					char ** newcon) { return 0; }
+const char *selinux_default_type_path(void) { return 0; }
+int get_default_type(const char *role, char **type) { return 0; }
+struct selabel_handle *selabel_open(unsigned int backend,
+					const struct selinux_opt *opts,
+					unsigned nopts) { return 0; }
+void selabel_close(struct selabel_handle *handle) { }
+int selabel_lookup(struct selabel_handle *handle, char **con,
+			const char *key, int type) { return 0; }
+int selabel_lookup_raw(struct selabel_handle *handle, char **con,
+			const char *key, int type) { return 0; }
+bool selabel_partial_match(struct selabel_handle *handle, const char *key) { return 0; }
+int selabel_lookup_best_match(struct selabel_handle *rec, char **con,
+				const char *key, const char **aliases, int type) { return 0; }
+int selabel_lookup_best_match_raw(struct selabel_handle *rec, char **con,
+				const char *key, const char **aliases, int type) { return 0; }
+int selabel_digest(struct selabel_handle *rec,
+				unsigned char **digest, size_t *digest_len,
+				char ***specfiles, size_t *num_specfiles) { return 0; }
+void selabel_stats(struct selabel_handle *handle) { }
+int selinux_restorecon(const char *pathname,
+					unsigned int restorecon_flags) { return 0; }
+struct selabel_handle *selinux_restorecon_default_handle(void) { return 0; }
+void selinux_restorecon_set_exclude_list(const char **exclude_list) { }
+int selinux_restorecon_set_alt_rootpath(const char *alt_rootpath) { return 0; }
+int selinux_restorecon_xattr(const char *pathname,
+					unsigned int xattr_flags,
+					struct dir_xattr ***xattr_list) { return 0; }

jni/external/stubs/sqlite3_stub.c

@@ -0,0 +1,676 @@
+#include "sqlite3.h"
+SQLITE_API const char *sqlite3_libversion(void) { return 0; }
+SQLITE_API const char *sqlite3_sourceid(void) { return 0; }
+SQLITE_API int sqlite3_libversion_number(void) { return 0; }
+#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
+SQLITE_API int sqlite3_compileoption_used(const char *zOptName) { return 0; }
+SQLITE_API const char *sqlite3_compileoption_get(int N) { return 0; }
+#endif
+SQLITE_API int sqlite3_threadsafe(void) { return 0; }
+SQLITE_API int sqlite3_close(sqlite3 *db) { return 0; }
+SQLITE_API int sqlite3_close_v2(sqlite3 *db) { return 0; }
+SQLITE_API int sqlite3_exec(
+  sqlite3 *db,
+  const char *sql,
+  int (*callback)(void*,int,char**,char**),
+  void *v,
+  char **errmsg
+) { return 0; }
+SQLITE_API int sqlite3_initialize(void) { return 0; }
+SQLITE_API int sqlite3_shutdown(void) { return 0; }
+SQLITE_API int sqlite3_os_init(void) { return 0; }
+SQLITE_API int sqlite3_os_end(void) { return 0; }
+SQLITE_API int sqlite3_config(int i, ...) { return 0; }
+SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...) { return 0; }
+SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3 *db) { return 0; }
+SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db,sqlite3_int64 i) { }
+SQLITE_API int sqlite3_changes(sqlite3 *db) { return 0; }
+SQLITE_API int sqlite3_total_changes(sqlite3 *db) { return 0; }
+SQLITE_API void sqlite3_interrupt(sqlite3 *db) { }
+SQLITE_API int sqlite3_complete(const char *sql) { return 0; }
+SQLITE_API int sqlite3_complete16(const void *sql) { return 0; }
+SQLITE_API int sqlite3_busy_handler(sqlite3 *db, int(*f) (void *v,int i), void* v) { return 0; }
+SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms) { return 0; }
+SQLITE_API int sqlite3_get_table(
+  sqlite3 *db,
+  const char *zSql,
+  char ***pazResult,
+  int *pnRow,
+  int *pnColumn,
+  char **pzErrmsg
+) { return 0; }
+SQLITE_API void sqlite3_free_table(char **result) { }
+SQLITE_API char *sqlite3_mprintf(const char* s,...) { return 0; }
+SQLITE_API char *sqlite3_vmprintf(const char* s, va_list v) { return 0; }
+SQLITE_API char *sqlite3_snprintf(int i, char* s, const char* st, ...) { return 0; }
+SQLITE_API char *sqlite3_vsnprintf(int i, char* s, const char* st, va_list v) { return 0; }
+SQLITE_API void *sqlite3_malloc(int i) { return 0; }
+SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 i) { return 0; }
+SQLITE_API void *sqlite3_realloc(void* v, int i) { return 0; }
+SQLITE_API void *sqlite3_realloc64(void* v, sqlite3_uint64 i) { return 0; }
+SQLITE_API void sqlite3_free(void* v) { }
+SQLITE_API sqlite3_uint64 sqlite3_msize(void* v) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_memory_used(void) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag) { return 0; }
+SQLITE_API void sqlite3_randomness(int N, void *P) { }
+SQLITE_API int sqlite3_set_authorizer(
+  sqlite3 *db,
+  int (*xAuth)(void *v,int i,const char*,const char*,const char*,const char*),
+  void *pUserData
+) { return 0; }
+SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3 *db,
+   void(*xTrace)(void *v,const char*), void* v) { return 0; }
+SQLITE_API SQLITE_DEPRECATED void *sqlite3_profile(sqlite3 *db,
+   void(*xProfile)(void *v,const char*,sqlite3_uint64), void* v) { return 0; }
+SQLITE_API int sqlite3_trace_v2(
+  sqlite3 *db,
+  unsigned uMask,
+  int(*xCallback)(unsigned,void *v,void *vv,void*),
+  void *pCtx
+) { return 0; }
+SQLITE_API void sqlite3_progress_handler(sqlite3 *db, int i, int(*f)(void*), void* v) { }
+SQLITE_API int sqlite3_open(
+  const char *filename,
+  sqlite3 **ppDb
+) { return 0; }
+SQLITE_API int sqlite3_open16(
+  const void *filename,
+  sqlite3 **ppDb
+) { return 0; }
+SQLITE_API int sqlite3_open_v2(
+  const char *filename,
+  sqlite3 **ppDb,
+  int flags,
+  const char *zVfs
+) { return 0; }
+SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam) { return 0; }
+SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char* s, const char* st, sqlite3_int64 i) { return 0; }
+SQLITE_API int sqlite3_errcode(sqlite3 *db) { return 0; }
+SQLITE_API int sqlite3_extended_errcode(sqlite3 *db) { return 0; }
+SQLITE_API const char *sqlite3_errmsg(sqlite3 *db) { return 0; }
+SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db) { return 0; }
+SQLITE_API const char *sqlite3_errstr(int i) { return 0; }
+SQLITE_API int sqlite3_limit(sqlite3 *db, int id, int newVal) { return 0; }
+SQLITE_API int sqlite3_prepare(
+  sqlite3 *db,
+  const char *zSql,
+  int nByte,
+  sqlite3_stmt **ppStmt,
+  const char **pzTail
+) { return 0; }
+SQLITE_API int sqlite3_prepare_v2(
+  sqlite3 *db,
+  const char *zSql,
+  int nByte,
+  sqlite3_stmt **ppStmt,
+  const char **pzTail
+) { return 0; }
+SQLITE_API int sqlite3_prepare16(
+  sqlite3 *db,
+  const void *zSql,
+  int nByte,
+  sqlite3_stmt **ppStmt,
+  const void **pzTail
+) { return 0; }
+SQLITE_API int sqlite3_prepare16_v2(
+  sqlite3 *db,
+  const void *zSql,
+  int nByte,
+  sqlite3_stmt **ppStmt,
+  const void **pzTail
+) { return 0; }
+SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt* s) { return 0; }
+SQLITE_API int sqlite3_bind_blob(sqlite3_stmt* s, int i, const void*v, int n, void(*f)(void*)) { return 0; }
+SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt* s, int i, const void *v, sqlite3_uint64 ii,
+                        void(*f)(void*)) { return 0; }
+SQLITE_API int sqlite3_bind_double(sqlite3_stmt* s, int i, double d) { return 0; }
+SQLITE_API int sqlite3_bind_int(sqlite3_stmt* s, int i, int ii) { return 0; }
+SQLITE_API int sqlite3_bind_int64(sqlite3_stmt* s, int i, sqlite3_int64 ii) { return 0; }
+SQLITE_API int sqlite3_bind_null(sqlite3_stmt* s, int i) { return 0; }
+SQLITE_API int sqlite3_bind_text(sqlite3_stmt* s,int i,const char* str, int ii, void(*f)(void*)) { return 0; }
+SQLITE_API int sqlite3_bind_text16(sqlite3_stmt* s, int i, const void *v, int ii, void(*f)(void*)) { return 0; }
+SQLITE_API int sqlite3_bind_text64(sqlite3_stmt* s, int i, const char* str, sqlite3_uint64 ii,
+                         void(*f)(void*), unsigned char encoding) { return 0; }
+SQLITE_API int sqlite3_bind_value(sqlite3_stmt* s, int i, const sqlite3_value* v) { return 0; }
+SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt* s, int i, int n) { return 0; }
+SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt* s, int i, sqlite3_uint64 ii) { return 0; }
+SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt* s) { return 0; }
+SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt* s, int i) { return 0; }
+SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt* s, const char *zName) { return 0; }
+SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt* s) { return 0; }
+SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API const char *sqlite3_column_name(sqlite3_stmt* s, int N) { return 0; }
+SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt* s, int N) { return 0; }
+SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt* s,int i){ return 0; }
+SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt* s,int i) { return 0; }
+SQLITE_API int sqlite3_step(sqlite3_stmt* s) { return 0; }
+SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API int sqlite3_column_bytes(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API double sqlite3_column_double(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API int sqlite3_column_int(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API int sqlite3_column_type(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt* s, int iCol) { return 0; }
+SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API int sqlite3_create_function(
+  sqlite3 *db,
+  const char *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context* c,int i,sqlite3_value**),
+  void (*xStep)(sqlite3_context* c,int i,sqlite3_value**),
+  void (*xFinal)(sqlite3_context* c)
+) { return 0; }
+SQLITE_API int sqlite3_create_function16(
+  sqlite3 *db,
+  const void *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context* c,int i,sqlite3_value**),
+  void (*xStep)(sqlite3_context* c,int i,sqlite3_value**),
+  void (*xFinal)(sqlite3_context* c)
+) { return 0; }
+SQLITE_API int sqlite3_create_function_v2(
+  sqlite3 *db,
+  const char *zFunctionName,
+  int nArg,
+  int eTextRep,
+  void *pApp,
+  void (*xFunc)(sqlite3_context* c,int i,sqlite3_value**),
+  void (*xStep)(sqlite3_context* c,int i,sqlite3_value**),
+  void (*xFinal)(sqlite3_context* c),
+  void(*xDestroy)(void*)
+) { return 0; }
+#ifndef SQLITE_OMIT_DEPRECATED
+SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context* c) { return 0; }
+SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt* s) { return 0; }
+SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt* s, sqlite3_stmt* ss) { return 0; }
+SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void) { return 0; }
+SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void) { }
+SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*f)(void *v,sqlite3_int64,int),
+                      void *v,sqlite3_int64 i) { return 0; }
+#endif
+SQLITE_API const void *sqlite3_value_blob(sqlite3_value* v) { return 0; }
+SQLITE_API int sqlite3_value_bytes(sqlite3_value* v) { return 0; }
+SQLITE_API int sqlite3_value_bytes16(sqlite3_value* v) { return 0; }
+SQLITE_API double sqlite3_value_double(sqlite3_value* v) { return 0; }
+SQLITE_API int sqlite3_value_int(sqlite3_value* v) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value* v) { return 0; }
+SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value* v) { return 0; }
+SQLITE_API const void *sqlite3_value_text16(sqlite3_value* v) { return 0; }
+SQLITE_API const void *sqlite3_value_text16le(sqlite3_value* v) { return 0; }
+SQLITE_API const void *sqlite3_value_text16be(sqlite3_value* v) { return 0; }
+SQLITE_API int sqlite3_value_type(sqlite3_value* v) { return 0; }
+SQLITE_API int sqlite3_value_numeric_type(sqlite3_value* v) { return 0; }
+SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value* v) { return 0; }
+SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value* v) { return 0; }
+SQLITE_API void sqlite3_value_free(sqlite3_value* v) { }
+SQLITE_API void *sqlite3_aggregate_context(sqlite3_context* c, int nBytes) { return 0; }
+SQLITE_API void *sqlite3_user_data(sqlite3_context* c) { return 0; }
+SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context* c) { return 0; }
+SQLITE_API void *sqlite3_get_auxdata(sqlite3_context* c, int N) { return 0; }
+SQLITE_API void sqlite3_set_auxdata(sqlite3_context* c, int N, void *v, void (*f)(void*)) { }
+SQLITE_API void sqlite3_result_blob(sqlite3_context* c, const void *v, int i, void(*f)(void*)) { }
+SQLITE_API void sqlite3_result_blob64(sqlite3_context* c,const void *v,
+                           sqlite3_uint64 i,void(*f)(void*)) { }
+SQLITE_API void sqlite3_result_double(sqlite3_context* c, double d) { }
+SQLITE_API void sqlite3_result_error(sqlite3_context* c, const char* s, int i) { }
+SQLITE_API void sqlite3_result_error16(sqlite3_context* c, const void *v, int i) { }
+SQLITE_API void sqlite3_result_error_toobig(sqlite3_context* c) { }
+SQLITE_API void sqlite3_result_error_nomem(sqlite3_context* c) { }
+SQLITE_API void sqlite3_result_error_code(sqlite3_context* c, int i) { }
+SQLITE_API void sqlite3_result_int(sqlite3_context* c, int i) { }
+SQLITE_API void sqlite3_result_int64(sqlite3_context* c, sqlite3_int64 i) { }
+SQLITE_API void sqlite3_result_null(sqlite3_context* c) { }
+SQLITE_API void sqlite3_result_text(sqlite3_context* c, const char* s, int i, void(*f)(void*)) { }
+SQLITE_API void sqlite3_result_text64(sqlite3_context* c, const char* s, sqlite3_uint64 i,
+                           void(*f)(void*), unsigned char encoding) { }
+SQLITE_API void sqlite3_result_text16(sqlite3_context* c, const void *v, int i, void(*f)(void*)) { }
+SQLITE_API void sqlite3_result_text16le(sqlite3_context* c, const void *v, int i,void(*f)(void*)) { }
+SQLITE_API void sqlite3_result_text16be(sqlite3_context* c, const void *v, int i,void(*f)(void*)) { }
+SQLITE_API void sqlite3_result_value(sqlite3_context* c, sqlite3_value* v) { }
+SQLITE_API void sqlite3_result_zeroblob(sqlite3_context* c, int n) { }
+SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context* c, sqlite3_uint64 n) { return 0; }
+SQLITE_API void sqlite3_result_subtype(sqlite3_context* c,unsigned int i) { }
+SQLITE_API int sqlite3_create_collation(
+  sqlite3 *db,
+  const char *zName,
+  int eTextRep,
+  void *pArg,
+  int(*xCompare)(void *,int,const void *,int,const void*)
+) { return 0; }
+SQLITE_API int sqlite3_create_collation_v2(
+  sqlite3 *db,
+  const char *zName,
+  int eTextRep,
+  void *pArg,
+  int(*xCompare)(void *,int,const void*,int,const void*),
+  void(*xDestroy)(void*)
+) { return 0; }
+SQLITE_API int sqlite3_create_collation16(
+  sqlite3 *db,
+  const void *zName,
+  int eTextRep,
+  void *pArg,
+  int(*xCompare)(void *,int,const void *,int,const void*)
+) { return 0; }
+SQLITE_API int sqlite3_collation_needed(
+  sqlite3 *db,
+  void *v,
+  void(*f)(void *v,sqlite3 *db,int eTextRep,const char*)
+) { return 0; }
+SQLITE_API int sqlite3_collation_needed16(
+  sqlite3 *db,
+  void *v,
+  void(*f)(void *v,sqlite3 *db,int eTextRep,const void*)
+) { return 0; }
+#ifdef SQLITE_HAS_CODEC
+SQLITE_API int sqlite3_key(
+  sqlite3 *db,
+  const void *pKey, int nKey
+) { return 0; }
+SQLITE_API int sqlite3_key_v2(
+  sqlite3 *db,
+  const char *zDbName,
+  const void *pKey, int nKey
+) { return 0; }
+SQLITE_API int sqlite3_rekey(
+  sqlite3 *db,
+  const void *pKey, int nKey
+) { return 0; }
+SQLITE_API int sqlite3_rekey_v2(
+  sqlite3 *db,
+  const char *zDbName,
+  const void *pKey, int nKey
+) { return 0; }
+SQLITE_API void sqlite3_activate_see(
+  const char *zPassPhrase
+) { return 0; }
+#endif
+#ifdef SQLITE_ENABLE_CEROD
+SQLITE_API void sqlite3_activate_cerod(
+  const char *zPassPhrase
+) { return 0; }
+#endif
+SQLITE_API int sqlite3_sleep(int i) { return 0; }
+SQLITE_API int sqlite3_get_autocommit(sqlite3 *db) { return 0; }
+SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *s) { return 0; }
+SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName) { return 0; }
+SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName) { return 0; }
+SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt) { return 0; }
+SQLITE_API void *sqlite3_commit_hook(sqlite3 *db, int(*f)(void*), void *v) { return 0; }
+SQLITE_API void *sqlite3_rollback_hook(sqlite3 *db, void(*f)(void *), void *v) { return 0; }
+SQLITE_API void *sqlite3_update_hook(
+  sqlite3 *db,
+  void(*f)(void *,int ,char const *,char const *,sqlite3_int64),
+  void *v
+) { return 0; }
+SQLITE_API int sqlite3_enable_shared_cache(int i) { return 0; }
+SQLITE_API int sqlite3_release_memory(int i) { return 0; }
+SQLITE_API int sqlite3_db_release_memory(sqlite3 *db) { return 0; }
+SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N) { return 0; }
+SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N) { }
+SQLITE_API int sqlite3_table_column_metadata(
+  sqlite3 *db,
+  const char *zDbName,
+  const char *zTableName,
+  const char *zColumnName,
+  char const **pzDataType,
+  char const **pzCollSeq,
+  int *pNotNull,
+  int *pPrimaryKey,
+  int *pAutoinc
+) { return 0; }
+SQLITE_API int sqlite3_load_extension(
+  sqlite3 *db,
+  const char *zFile,
+  const char *zProc,
+  char **pzErrMsg
+) { return 0; }
+SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff) { return 0; }
+SQLITE_API int sqlite3_auto_extension(void(*xEntryPoint)(void)) { return 0; }
+SQLITE_API int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void)) { return 0; }
+SQLITE_API void sqlite3_reset_auto_extension(void) { }
+SQLITE_API int sqlite3_create_module(
+  sqlite3 *db,
+  const char *zName,
+  const sqlite3_module *p,
+  void *pClientData
+) { return 0; }
+SQLITE_API int sqlite3_create_module_v2(
+  sqlite3 *db,
+  const char *zName,
+  const sqlite3_module *p,
+  void *pClientData,
+  void(*xDestroy)(void*)
+) { return 0; }
+SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zSQL) { return 0; }
+SQLITE_API int sqlite3_overload_function(sqlite3 *db, const char *zFuncName, int nArg) { return 0; }
+SQLITE_API int sqlite3_blob_open(
+  sqlite3 *db,
+  const char *zDb,
+  const char *zTable,
+  const char *zColumn,
+  sqlite3_int64 iRow,
+  int flags,
+  sqlite3_blob **ppBlob
+) { return 0; }
+SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *b, sqlite3_int64 i) { return 0; }
+SQLITE_API int sqlite3_blob_close(sqlite3_blob *b) { return 0; }
+SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *b) { return 0; }
+SQLITE_API int sqlite3_blob_read(sqlite3_blob *b, void *Z, int N, int iOffset) { return 0; }
+SQLITE_API int sqlite3_blob_write(sqlite3_blob *b, const void *z, int n, int iOffset) { return 0; }
+SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName) { return 0; }
+SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *v, int makeDflt) { return 0; }
+SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *v) { return 0; }
+SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int i) { return 0; }
+SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *m) { }
+SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *m) { }
+SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *m) { return 0; }
+SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *m) { }
+#ifndef NDEBUG
+SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *m) { return 0; }
+SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *m) { return 0; }
+#endif
+SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3* db) { return 0; }
+SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void* v) { return 0; }
+SQLITE_API int sqlite3_test_control(int op, ...) { return 0; }
+SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag) { return 0; }
+SQLITE_API int sqlite3_status64(
+  int op,
+  sqlite3_int64 *pCurrent,
+  sqlite3_int64 *pHighwater,
+  int resetFlag
+) { return 0; }
+SQLITE_API int sqlite3_db_status(sqlite3 *db, int op, int *pCur, int *pHiwtr, int resetFlg) { return 0; }
+SQLITE_API int sqlite3_stmt_status(sqlite3_stmt* s, int op,int resetFlg) { return 0; }
+SQLITE_API sqlite3_backup *sqlite3_backup_init(
+  sqlite3 *pDest,
+  const char *zDestName,
+  sqlite3 *pSource,
+  const char *zSourceName
+) { return 0; }
+SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage) { return 0; }
+SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p) { return 0; }
+SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p) { return 0; }
+SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p) { return 0; }
+SQLITE_API int sqlite3_unlock_notify(
+  sqlite3 *pBlocked,
+  void (*xNotify)(void **apArg, int nArg),
+  void *pNotifyArg
+) { return 0; }
+SQLITE_API int sqlite3_stricmp(const char *s, const char *ss) { return 0; }
+SQLITE_API int sqlite3_strnicmp(const char *s, const char *ss, int i) { return 0; }
+SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr) { return 0; }
+SQLITE_API int sqlite3_strlike(const char *zGlob, const char *zStr, unsigned int cEsc) { return 0; }
+SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...) { }
+SQLITE_API void *sqlite3_wal_hook(
+  sqlite3 *db,
+  int(*f)(void *,sqlite3 *db,const char*,int i),
+  void *v
+) { return 0; }
+SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N) { return 0; }
+SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb) { return 0; }
+SQLITE_API int sqlite3_wal_checkpoint_v2(
+  sqlite3 *db,
+  const char *zDb,
+  int eMode,
+  int *pnLog,
+  int *pnCkpt
+) { return 0; }
+#define SQLITE_CHECKPOINT_PASSIVE  0
+#define SQLITE_CHECKPOINT_FULL     1
+#define SQLITE_CHECKPOINT_RESTART  2
+#define SQLITE_CHECKPOINT_TRUNCATE 3
+SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...) { return 0; }
+#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1
+SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *db) { return 0; }
+#define SQLITE_ROLLBACK 1
+#define SQLITE_FAIL     3
+#define SQLITE_REPLACE  5
+#define SQLITE_SCANSTAT_NLOOP    0
+#define SQLITE_SCANSTAT_NVISIT   1
+#define SQLITE_SCANSTAT_EST      2
+#define SQLITE_SCANSTAT_NAME     3
+#define SQLITE_SCANSTAT_EXPLAIN  4
+#define SQLITE_SCANSTAT_SELECTID 5
+SQLITE_API int sqlite3_stmt_scanstatus(
+  sqlite3_stmt *pStmt,
+  int idx,
+  int iScanStatusOp,
+  void *pOut
+) { return 0; }
+SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *s) { }
+SQLITE_API int sqlite3_db_cacheflush(sqlite3* db) { return 0; }
+#if defined(SQLITE_ENABLE_PREUPDATE_HOOK)
+SQLITE_API void *sqlite3_preupdate_hook(
+  sqlite3 *db,
+  void(*xPreUpdate)(
+    void *pCtx,
+    sqlite3 *db,
+    int op,
+    char const *zDb,
+    char const *zName,
+    sqlite3_int64 iKey1,
+    sqlite3_int64 iKey2
+  ),
+  void*
+) { return 0; }
+SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int i, sqlite3_value **) { return 0; }
+SQLITE_API int sqlite3_preupdate_count(sqlite3 *) { return 0; }
+SQLITE_API int sqlite3_preupdate_depth(sqlite3 *) { return 0; }
+SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int i, sqlite3_value **) { return 0; }
+#endif
+SQLITE_API int sqlite3_system_errno(sqlite3 *db) { return 0; }
+SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
+  sqlite3 *db,
+  const char *zSchema,
+  sqlite3_snapshot **ppSnapshot
+) { return 0; }
+SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open(
+  sqlite3 *db,
+  const char *zSchema,
+  sqlite3_snapshot *pSnapshot
+) { return 0; }
+SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot* s) { }
+SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp(
+  sqlite3_snapshot *p1,
+  sqlite3_snapshot *p2
+) { return 0; }
+SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb) { return 0; }
+SQLITE_API int sqlite3_rtree_geometry_callback(
+  sqlite3 *db,
+  const char *zGeom,
+  int (*xGeom)(sqlite3_rtree_geometry*, int i, sqlite3_rtree_dbl*,int*),
+  void *pContext
+) { return 0; }
+SQLITE_API int sqlite3_rtree_query_callback(
+  sqlite3 *db,
+  const char *zQueryFunc,
+  int (*xQueryFunc)(sqlite3_rtree_query_info*),
+  void *pContext,
+  void (*xDestructor)(void*)
+) { return 0; }
+typedef struct sqlite3_session sqlite3_session;
+typedef struct sqlite3_changeset_iter sqlite3_changeset_iter;
+SQLITE_API int sqlite3session_create(
+  sqlite3 *db,
+  const char *zDb,
+  sqlite3_session **ppSession
+) { return 0; }
+SQLITE_API void sqlite3session_delete(sqlite3_session *pSession) { }
+SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable) { return 0; }
+SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect) { return 0; }
+SQLITE_API int sqlite3session_attach(
+  sqlite3_session *pSession,
+  const char *zTab
+) { return 0; }
+SQLITE_API void sqlite3session_table_filter(
+  sqlite3_session *pSession,
+  int(*xFilter)(
+    void *pCtx,
+    const char *zTab
+  ),
+  void *pCtx
+) { }
+SQLITE_API int sqlite3session_changeset(
+  sqlite3_session *pSession,
+  int *pnChangeset,
+  void **ppChangeset
+) { return 0; }
+SQLITE_API int sqlite3session_diff(
+  sqlite3_session *pSession,
+  const char *zFromDb,
+  const char *zTbl,
+  char **pzErrMsg
+) { return 0; }
+SQLITE_API int sqlite3session_patchset(
+  sqlite3_session *pSession,
+  int *pnPatchset,
+  void **ppPatchset
+) { return 0; }
+SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession) { return 0; }
+SQLITE_API int sqlite3changeset_start(
+  sqlite3_changeset_iter **pp,
+  int nChangeset,
+  void *pChangeset
+) { return 0; }
+SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter) { return 0; }
+SQLITE_API int sqlite3changeset_op(
+  sqlite3_changeset_iter *pIter,
+  const char **pzTab,
+  int *pnCol,
+  int *pOp,
+  int *pbIndirect
+) { return 0; }
+SQLITE_API int sqlite3changeset_pk(
+  sqlite3_changeset_iter *pIter,
+  unsigned char **pabPK,
+  int *pnCol
+) { return 0; }
+SQLITE_API int sqlite3changeset_old(
+  sqlite3_changeset_iter *pIter,
+  int iVal,
+  sqlite3_value **ppValue
+) { return 0; }
+SQLITE_API int sqlite3changeset_new(
+  sqlite3_changeset_iter *pIter,
+  int iVal,
+  sqlite3_value **ppValue
+) { return 0; }
+SQLITE_API int sqlite3changeset_conflict(
+  sqlite3_changeset_iter *pIter,
+  int iVal,
+  sqlite3_value **ppValue
+) { return 0; }
+SQLITE_API int sqlite3changeset_fk_conflicts(
+  sqlite3_changeset_iter *pIter,
+  int *pnOut
+) { return 0; }
+SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter) { return 0; }
+SQLITE_API int sqlite3changeset_invert(
+  int nIn, const void *pIn,
+  int *pnOut, void **ppOut
+) { return 0; }
+SQLITE_API int sqlite3changeset_concat(
+  int nA,
+  void *pA,
+  int nB,
+  void *pB,
+  int *pnOut,
+  void **ppOut
+) { return 0; }
+typedef struct sqlite3_changegroup sqlite3_changegroup;
+int sqlite3changegroup_new(sqlite3_changegroup **pp) { return 0; }
+int sqlite3changegroup_add(sqlite3_changegroup *c, int nData, void *pData) { return 0; }
+int sqlite3changegroup_output(
+  sqlite3_changegroup *c,
+  int *pnData,
+  void **ppData
+) { return 0; }
+void sqlite3changegroup_delete(sqlite3_changegroup *c) { }
+SQLITE_API int sqlite3changeset_apply(
+  sqlite3 *db,
+  int nChangeset,
+  void *pChangeset,
+  int(*xFilter)(
+    void *pCtx,
+    const char *zTab
+  ),
+  int(*xConflict)(
+    void *pCtx,
+    int eConflict,
+    sqlite3_changeset_iter *p
+  ),
+  void *pCtx
+) { return 0; }
+SQLITE_API int sqlite3changeset_apply_strm(
+  sqlite3 *db,
+  int (*xInput)(void *pIn, void *pData, int *pnData),
+  void *pIn,
+  int(*xFilter)(
+    void *pCtx,
+    const char *zTab
+  ),
+  int(*xConflict)(
+    void *pCtx,
+    int eConflict,
+    sqlite3_changeset_iter *p
+  ),
+  void *pCtx
+) { return 0; }
+SQLITE_API int sqlite3changeset_concat_strm(
+  int (*xInputA)(void *pIn, void *pData, int *pnData),
+  void *pInA,
+  int (*xInputB)(void *pIn, void *pData, int *pnData),
+  void *pInB,
+  int (*xOutput)(void *pOut, const void *pData, int nData),
+  void *pOut
+) { return 0; }
+SQLITE_API int sqlite3changeset_invert_strm(
+  int (*xInput)(void *pIn, void *pData, int *pnData),
+  void *pIn,
+  int (*xOutput)(void *pOut, const void *pData, int nData),
+  void *pOut
+) { return 0; }
+SQLITE_API int sqlite3changeset_start_strm(
+  sqlite3_changeset_iter **pp,
+  int (*xInput)(void *pIn, void *pData, int *pnData),
+  void *pIn
+) { return 0; }
+SQLITE_API int sqlite3session_changeset_strm(
+  sqlite3_session *pSession,
+  int (*xOutput)(void *pOut, const void *pData, int nData),
+  void *pOut
+) { return 0; }
+SQLITE_API int sqlite3session_patchset_strm(
+  sqlite3_session *pSession,
+  int (*xOutput)(void *pOut, const void *pData, int nData),
+  void *pOut
+) { return 0; }
+int sqlite3changegroup_add_strm(sqlite3_changegroup *c,
+    int (*xInput)(void *pIn, void *pData, int *pnData),
+    void *pIn
+) { return 0; }
+int sqlite3changegroup_output_strm(sqlite3_changegroup *c,
+    int (*xOutput)(void *pOut, const void *pData, int nData),
+    void *pOut
+) { return 0; }

jni/external/xz_config/config.h

@@ -0,0 +1,498 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* How many MiB of RAM to assume if the real amount cannot be determined. */
+#define ASSUME_RAM 128
+
+/* Define to 1 if translation of program messages to the user's native
+   language is requested. */
+/* #undef ENABLE_NLS */
+
+/* Define to 1 if bswap_16 is available. */
+#define HAVE_BSWAP_16 1
+
+/* Define to 1 if bswap_32 is available. */
+#define HAVE_BSWAP_32 1
+
+/* Define to 1 if bswap_64 is available. */
+#define HAVE_BSWAP_64 1
+
+/* Define to 1 if you have the <byteswap.h> header file. */
+#define HAVE_BYTESWAP_H 1
+
+/* Define to 1 if Capsicum is available. */
+/* #undef HAVE_CAPSICUM */
+
+/* Define to 1 if the system has the type `CC_SHA256_CTX'. */
+/* #undef HAVE_CC_SHA256_CTX */
+
+/* Define to 1 if you have the `CC_SHA256_Init' function. */
+/* #undef HAVE_CC_SHA256_INIT */
+
+/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the
+   CoreFoundation framework. */
+/* #undef HAVE_CFLOCALECOPYCURRENT */
+
+/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in
+   the CoreFoundation framework. */
+/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
+
+/* Define to 1 if crc32 integrity check is enabled. */
+#define HAVE_CHECK_CRC32 1
+
+/* Define to 1 if crc64 integrity check is enabled. */
+#define HAVE_CHECK_CRC64 1
+
+/* Define to 1 if sha256 integrity check is enabled. */
+#define HAVE_CHECK_SHA256 1
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if you have the <CommonCrypto/CommonDigest.h> header file. */
+/* #undef HAVE_COMMONCRYPTO_COMMONDIGEST_H */
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+/* #undef HAVE_DCGETTEXT */
+
+/* Define to 1 if you have the declaration of `CLOCK_MONOTONIC', and to 0 if
+   you don't. */
+#define HAVE_DECL_CLOCK_MONOTONIC 1
+
+/* Define to 1 if you have the declaration of `program_invocation_name', and
+   to 0 if you don't. */
+#define HAVE_DECL_PROGRAM_INVOCATION_NAME 0
+
+/* Define to 1 if any of HAVE_DECODER_foo have been defined. */
+#define HAVE_DECODERS 1
+
+/* Define to 1 if arm decoder is enabled. */
+#define HAVE_DECODER_ARM 1
+
+/* Define to 1 if armthumb decoder is enabled. */
+#define HAVE_DECODER_ARMTHUMB 1
+
+/* Define to 1 if delta decoder is enabled. */
+#define HAVE_DECODER_DELTA 1
+
+/* Define to 1 if ia64 decoder is enabled. */
+#define HAVE_DECODER_IA64 1
+
+/* Define to 1 if lzma1 decoder is enabled. */
+#define HAVE_DECODER_LZMA1 1
+
+/* Define to 1 if lzma2 decoder is enabled. */
+#define HAVE_DECODER_LZMA2 1
+
+/* Define to 1 if powerpc decoder is enabled. */
+#define HAVE_DECODER_POWERPC 1
+
+/* Define to 1 if sparc decoder is enabled. */
+#define HAVE_DECODER_SPARC 1
+
+/* Define to 1 if x86 decoder is enabled. */
+#define HAVE_DECODER_X86 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if any of HAVE_ENCODER_foo have been defined. */
+#define HAVE_ENCODERS 1
+
+/* Define to 1 if arm encoder is enabled. */
+#define HAVE_ENCODER_ARM 1
+
+/* Define to 1 if armthumb encoder is enabled. */
+#define HAVE_ENCODER_ARMTHUMB 1
+
+/* Define to 1 if delta encoder is enabled. */
+#define HAVE_ENCODER_DELTA 1
+
+/* Define to 1 if ia64 encoder is enabled. */
+#define HAVE_ENCODER_IA64 1
+
+/* Define to 1 if lzma1 encoder is enabled. */
+#define HAVE_ENCODER_LZMA1 1
+
+/* Define to 1 if lzma2 encoder is enabled. */
+#define HAVE_ENCODER_LZMA2 1
+
+/* Define to 1 if powerpc encoder is enabled. */
+#define HAVE_ENCODER_POWERPC 1
+
+/* Define to 1 if sparc encoder is enabled. */
+#define HAVE_ENCODER_SPARC 1
+
+/* Define to 1 if x86 encoder is enabled. */
+#define HAVE_ENCODER_X86 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `futimens' function. */
+#define HAVE_FUTIMENS 1
+
+/* Define to 1 if you have the `futimes' function. */
+/* #undef HAVE_FUTIMES */
+
+/* Define to 1 if you have the `futimesat' function. */
+/* #undef HAVE_FUTIMESAT */
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#define HAVE_GETOPT_H 1
+
+/* Define to 1 if you have the `getopt_long' function. */
+#define HAVE_GETOPT_LONG 1
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+/* #undef HAVE_GETTEXT */
+
+/* Define if you have the iconv() function and it works. */
+/* #undef HAVE_ICONV */
+
+/* Define to 1 if you have the <immintrin.h> header file. */
+/* #undef HAVE_IMMINTRIN_H */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if mbrtowc and mbstate_t are properly declared. */
+#define HAVE_MBRTOWC 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 to enable bt2 match finder. */
+#define HAVE_MF_BT2 1
+
+/* Define to 1 to enable bt3 match finder. */
+#define HAVE_MF_BT3 1
+
+/* Define to 1 to enable bt4 match finder. */
+#define HAVE_MF_BT4 1
+
+/* Define to 1 to enable hc3 match finder. */
+#define HAVE_MF_HC3 1
+
+/* Define to 1 to enable hc4 match finder. */
+#define HAVE_MF_HC4 1
+
+/* Define to 1 if you have the <minix/sha2.h> header file. */
+/* #undef HAVE_MINIX_SHA2_H */
+
+/* Define to 1 if getopt.h declares extern int optreset. */
+#define HAVE_OPTRESET 1
+
+/* Define to 1 if you have the `posix_fadvise' function. */
+#define HAVE_POSIX_FADVISE 1
+
+/* Define to 1 if you have the `pthread_condattr_setclock' function. */
+#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1
+
+/* Have PTHREAD_PRIO_INHERIT. */
+/* #undef HAVE_PTHREAD_PRIO_INHERIT */
+
+/* Define to 1 if you have the `SHA256Init' function. */
+/* #undef HAVE_SHA256INIT */
+
+/* Define to 1 if the system has the type `SHA256_CTX'. */
+/* #undef HAVE_SHA256_CTX */
+
+/* Define to 1 if you have the <sha256.h> header file. */
+/* #undef HAVE_SHA256_H */
+
+/* Define to 1 if you have the `SHA256_Init' function. */
+/* #undef HAVE_SHA256_INIT */
+
+/* Define to 1 if the system has the type `SHA2_CTX'. */
+/* #undef HAVE_SHA2_CTX */
+
+/* Define to 1 if you have the <sha2.h> header file. */
+/* #undef HAVE_SHA2_H */
+
+/* Define to 1 if optimizing for size. */
+/* #undef HAVE_SMALL */
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#define HAVE_STDBOOL_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if `st_atimensec' is a member of `struct stat'. */
+#define HAVE_STRUCT_STAT_ST_ATIMENSEC 1
+
+/* Define to 1 if `st_atimespec.tv_nsec' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC */
+
+/* Define to 1 if `st_atim.st__tim.tv_nsec' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC */
+
+/* Define to 1 if `st_atim.tv_nsec' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC */
+
+/* Define to 1 if `st_uatime' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_UATIME */
+
+/* Define to 1 if you have the <sys/byteorder.h> header file. */
+/* #undef HAVE_SYS_BYTEORDER_H */
+
+/* Define to 1 if you have the <sys/capsicum.h> header file. */
+/* #undef HAVE_SYS_CAPSICUM_H */
+
+/* Define to 1 if you have the <sys/endian.h> header file. */
+/* #undef HAVE_SYS_ENDIAN_H */
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#define HAVE_SYS_PARAM_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+#define HAVE_SYS_TIME_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if the system has the type `uintptr_t'. */
+#define HAVE_UINTPTR_T 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `utime' function. */
+/* #undef HAVE_UTIME */
+
+/* Define to 1 if you have the `utimes' function. */
+/* #undef HAVE_UTIMES */
+
+/* Define to 1 or 0, depending whether the compiler supports simple visibility
+   declarations. */
+#define HAVE_VISIBILITY 1
+
+/* Define to 1 if you have the `wcwidth' function. */
+#define HAVE_WCWIDTH 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#define HAVE__BOOL 1
+
+/* Define to 1 if _mm_movemask_epi8 is available. */
+/* #undef HAVE__MM_MOVEMASK_EPI8 */
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+/* Define to 1 when using POSIX threads (pthreads). */
+#define MYTHREAD_POSIX 1
+
+/* Define to 1 when using Windows Vista compatible threads. This uses features
+   that are not available on Windows XP. */
+/* #undef MYTHREAD_VISTA */
+
+/* Define to 1 when using Windows 95 (and thus XP) compatible threads. This
+   avoids use of features that were added in Windows Vista. */
+/* #undef MYTHREAD_WIN95 */
+
+/* Define to 1 to disable debugging code. */
+#define NDEBUG 1
+
+/* Name of package */
+#define PACKAGE "xz"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "lasse.collin@tukaani.org"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "XZ Utils"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "XZ Utils 5.3.0alpha"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "xz"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "http://tukaani.org/xz/"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "5.3.0alpha"
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* The size of `size_t', as computed by sizeof. */
+#define SIZEOF_SIZE_T 4
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   cpuset(2). */
+/* #undef TUKLIB_CPUCORES_CPUSET */
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   pstat_getdynamic(). */
+/* #undef TUKLIB_CPUCORES_PSTAT_GETDYNAMIC */
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   sysconf(_SC_NPROCESSORS_ONLN) or sysconf(_SC_NPROC_ONLN). */
+#define TUKLIB_CPUCORES_SYSCONF 1
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   sysctl(). */
+/* #undef TUKLIB_CPUCORES_SYSCTL */
+
+/* Define to 1 if the system supports fast unaligned access to 16-bit and
+   32-bit integers. */
+/* #undef TUKLIB_FAST_UNALIGNED_ACCESS */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   _system_configuration.physmem. */
+/* #undef TUKLIB_PHYSMEM_AIX */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   getinvent_r(). */
+/* #undef TUKLIB_PHYSMEM_GETINVENT_R */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   getsysinfo(). */
+/* #undef TUKLIB_PHYSMEM_GETSYSINFO */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   pstat_getstatic(). */
+/* #undef TUKLIB_PHYSMEM_PSTAT_GETSTATIC */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   sysconf(_SC_PAGESIZE) and sysconf(_SC_PHYS_PAGES). */
+#define TUKLIB_PHYSMEM_SYSCONF 1
+
+/* Define to 1 if the amount of physical memory can be detected with sysctl().
+   */
+/* #undef TUKLIB_PHYSMEM_SYSCTL */
+
+/* Define to 1 if the amount of physical memory can be detected with Linux
+   sysinfo(). */
+/* #undef TUKLIB_PHYSMEM_SYSINFO */
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
+
+/* Version number of package */
+#define VERSION "5.3.0alpha"
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Enable large inode numbers on Mac OS X 10.5.  */
+#ifndef _DARWIN_USE_64_BIT_INODE
+# define _DARWIN_USE_64_BIT_INODE 1
+#endif
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to 1 if on MINIX. */
+/* #undef _MINIX */
+
+/* Define to 2 if the system does not provide POSIX.1 features except with
+   this defined. */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define to 1 if you need to in order for `stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+
+/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+/* #undef _UINT32_T */
+
+/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+/* #undef _UINT64_T */
+
+/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+/* #undef _UINT8_T */
+
+/* Define to rpl_ if the getopt replacement functions and variables should be
+   used. */
+/* #undef __GETOPT_PREFIX */
+
+/* Define to the type of a signed integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef int32_t */
+
+/* Define to the type of a signed integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef int64_t */
+
+/* Define to the type of an unsigned integer type of width exactly 16 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint16_t */
+
+/* Define to the type of an unsigned integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint32_t */
+
+/* Define to the type of an unsigned integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint64_t */
+
+/* Define to the type of an unsigned integer type of width exactly 8 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint8_t */
+
+/* Define to the type of an unsigned integer type wide enough to hold a
+   pointer, if such a type exists, and if the system does not define it. */
+/* #undef uintptr_t */

jni/include/daemon.h

@@ -7,6 +7,7 @@
 #include <pthread.h>
 
 extern pthread_t sepol_patch;
+extern int is_restart;
 
 // Commands require connecting to daemon
 typedef enum {
@@ -15,6 +16,7 @@ typedef enum {
 	STOP_MAGISKHIDE,
 	ADD_HIDELIST,
 	RM_HIDELIST,
+	LS_HIDELIST,
 	SUPERUSER,
 	CHECK_VERSION,
 	CHECK_VERSION_CODE,
@@ -37,11 +39,9 @@ typedef enum {
 
 // daemon.c
 
-void start_daemon(int client);
+void start_daemon();
 int connect_daemon();
-
-// socket_trans.c
-
+void auto_start_magiskhide();
 int recv_fd(int sockfd);
 void send_fd(int sockfd, int fd);
 int read_int(int fd);
@@ -49,10 +49,6 @@ void write_int(int fd, int val);
 char* read_string(int fd);
 void write_string(int fd, const char* val);
 
-// log_monitor.c
-
-void monitor_logs();
-
 /***************
  * Boot Stages *
  ***************/
@@ -60,6 +56,7 @@ void monitor_logs();
 void post_fs(int client);
 void post_fs_data(int client);
 void late_start(int client);
+void fix_filecon();
 
 /**************
  * MagiskHide *
@@ -69,6 +66,7 @@ void launch_magiskhide(int client);
 void stop_magiskhide(int client);
 void add_hide_list(int client);
 void rm_hide_list(int client);
+void ls_hide_list(int client);
 
 /*************
  * Superuser *

jni/include/list.h

@@ -0,0 +1,43 @@
+/* list.h - Double link list implementation
+ */
+
+#ifndef _LIST_H_
+#define _LIST_H_
+
+#include <stddef.h>
+
+struct list_head {
+	struct list_head *next;
+	struct list_head *prev;
+};
+
+void init_list_head(struct list_head *head);
+void list_insert(struct list_head *pos, struct list_head *node);
+void list_insert_end(struct list_head *head, struct list_head *node);
+struct list_head *list_pop(struct list_head *pos);
+struct list_head *list_pop_end(struct list_head *head);
+
+#define list_entry(pos, type, member) ({ \
+	const typeof( ((type *)0)->member ) *__mptr = (pos); \
+	(type *)( (char *)__mptr - offsetof(type,member) );})
+
+#define list_for_each(ptr, head, type, member) \
+	ptr = list_entry((head)->next, type, member); \
+	for (struct list_head *__ = (head)->next; __ != (head); __ = __->next, ptr = list_entry(__, type, member))
+
+#define list_for_each_r(ptr, head, type, member) \
+	ptr = list_entry((head)->prev, type, member); \
+	for (struct list_head *__ = (head)->prev; __ != (head); __ = __->prev, ptr = list_entry(__, type, member))
+
+#define list_destory(head, type, member, func) ({ \
+	struct list_head *node = head->next; \
+	while(node != head) { \
+		node = node->next; \
+		if (func) func(list_entry(node->prev, line_list, pos)); \
+		free(list_entry(node->prev, line_list, pos)); \
+	} \
+	head->next = head; \
+	head->prev = head; \
+})
+
+#endif

jni/include/logging.h

@@ -0,0 +1,53 @@
+/* logging.h - Error handling and logging
+ */
+
+#ifndef _LOGGING_H_
+#define _LOGGING_H_
+
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#define str(a) #a
+#define xstr(a) str(a)
+
+#ifdef IS_DAEMON
+
+#include <pthread.h>
+#include <android/log.h>
+
+#define LOG_TAG    "Magisk"
+
+#ifdef MAGISK_DEBUG
+#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#else
+#define LOGD(...)
+#endif
+#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGW(...)  __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+#define PLOGE(fmt, args...) LOGE(fmt " failed with %d: %s", ##args, errno, strerror(errno))
+
+enum {
+	HIDE_EVENT,
+	LOG_EVENT,
+	DEBUG_EVENT
+};
+extern int logcat_events[];
+
+void monitor_logs();
+void start_debug_full_log();
+void stop_debug_full_log();
+void start_debug_log();
+
+#else // IS_DAEMON
+
+#include <stdio.h>
+
+#define LOGE(...) { fprintf(stderr, __VA_ARGS__); exit(1); }
+#define PLOGE(fmt, args...) { fprintf(stderr, fmt " failed with %d: %s\n\n", ##args, errno, strerror(errno)); exit(1); }
+
+#endif // IS_DAEMON
+
+#endif // _LOGGING_H_

jni/include/magisk.h

@@ -4,21 +4,10 @@
 #ifndef _MAGISK_H_
 #define _MAGISK_H_
 
-#include <stdlib.h>
-#include <errno.h>
-#include <string.h>
-#include <pthread.h>
-#include <android/log.h>
+#include "logging.h"
 
 #define MAGISK_VER_STR  xstr(MAGISK_VERSION) ":MAGISK"
-
-#define str(a) #a
-#define xstr(a) str(a)
-
 #define REQUESTOR_DAEMON_PATH     "\0MAGISK"
-#define REQUESTOR_DAEMON_PATH_LEN 7
-
-#define LOG_TAG    "Magisk"
 
 #ifndef ARG_MAX
 #define ARG_MAX 4096
@@ -28,19 +17,24 @@
 #define LASTLOG         "/cache/last_magisk.log"
 #define DEBUG_LOG       "/data/magisk_debug.log"
 #define UNBLOCKFILE     "/dev/.magisk.unblock"
+#define PATCHSTART      "/dev/.magisk.patch.start"
+#define PATCHDONE       "/dev/.magisk.patch.done"
 #define DISABLEFILE     "/cache/.disable_magisk"
 #define UNINSTALLER     "/cache/magisk_uninstaller.sh"
-#define MOUNTPOINT      "/magisk"
+#define CACHEMOUNT      "/cache/magisk_mount"
+#define MAGISKTMP       "/sbin/.core"
+#define MIRRDIR         MAGISKTMP "/mirror"
+#define BBPATH          MAGISKTMP "/busybox"
+#define MOUNTPOINT      MAGISKTMP "/img"
+#define FAKEPOINT       "/magisk"
 #define COREDIR         MOUNTPOINT "/.core"
 #define HOSTSFILE       COREDIR "/hosts"
 #define HIDELIST        COREDIR "/hidelist"
 #define MAINIMG         "/data/magisk.img"
 #define DATABIN         "/data/magisk"
-#define MANAGERAPK      DATABIN "/magisk.apk"
-#define MAGISKTMP       "/dev/magisk"
-#define MIRRDIR         MAGISKTMP "/mirror"
-#define DUMMDIR         MAGISKTMP "/dummy"
-#define CACHEMOUNT      "/cache/magisk_mount"
+#define MANAGERAPK      MIRRDIR "/bin/magisk.apk"
+#define MAGISKRC        "/init.magisk.rc"
+
 
 #define SELINUX_PATH        "/sys/fs/selinux/"
 #define SELINUX_ENFORCE     SELINUX_PATH "enforce"
@@ -49,33 +43,12 @@
 
 #define MAGISKHIDE_PROP     "persist.magisk.hide"
 
-// Global handler for PLOGE
-extern __thread void (*err_handler)(void);
-
-// Common error handlers
-static inline void exit_proc() { exit(1); }
-static inline void exit_thread() { pthread_exit(NULL); }
-static inline void do_nothing() {}
-
-// Dummy function to depress debug message
-static inline void stub(const char *fmt, ...) {}
-
-#ifdef DEBUG
-#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
-#else
-#define LOGD(...)  stub(__VA_ARGS__)
-#endif
-#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
-#define LOGW(...)  __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
-#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-
-#define PLOGE(fmt, args...) { LOGE(fmt " failed with %d: %s", ##args, errno, strerror(errno)); err_handler(); }
-
 extern char *argv0;     /* For changing process name */
 
 extern char *applet[];
 extern int (*applet_main[]) (int, char *[]);
-extern int null_fd;
+
+int create_links(const char *bin, const char *path);
 
 // Multi-call entrypoints
 int magiskhide_main(int argc, char *argv[]);

jni/include/magiskpolicy.h

@@ -0,0 +1,36 @@
+/* magiskpolicy.h - Public API for policy patching
+ */
+
+#ifndef _MAGISKPOLICY_H
+#define _MAGISKPOLICY_H
+
+#include <stdlib.h>
+
+#define ALL NULL
+
+// policydb functions
+int load_policydb(const char *filename);
+int dump_policydb(const char *filename);
+void destroy_policydb();
+
+// Handy functions
+int sepol_allow(char *s, char *t, char *c, char *p);
+int sepol_deny(char *s, char *t, char *c, char *p);
+int sepol_auditallow(char *s, char *t, char *c, char *p);
+int sepol_auditdeny(char *s, char *t, char *c, char *p);
+int sepol_typetrans(char *s, char *t, char *c, char *d, char *o);
+int sepol_allowxperm(char *s, char *t, char *c, char *range);
+int sepol_auditallowxperm(char *s, char *t, char *c, char *range);
+int sepol_dontauditxperm(char *s, char *t, char *c, char *range);
+int sepol_create(char *s);
+int sepol_permissive(char *s);
+int sepol_enforce(char *s);
+int sepol_attradd(char *s, char *a);
+int sepol_exists(char *source);
+
+// Built in rules
+void sepol_min_rules();
+void sepol_med_rules();
+void sepol_full_rules();
+
+#endif

jni/include/magiskrc.h

@@ -0,0 +1,46 @@
+const char magiskrc[] =
+
+// Triggers
+
+"on post-fs\n"
+"   start logd\n"
+"   start magisk_daemon\n"
+"   wait /dev/.magisk.unblock 5\n"
+"   rm /dev/.magisk.unblock\n"
+"   start magisk_pfs\n"
+"   wait /dev/.magisk.unblock 10\n"
+"\n"
+
+"on post-fs-data\n"
+"   load_persist_props\n"
+"   rm /dev/.magisk.unblock\n"
+"   start magisk_pfsd\n"
+"   wait /dev/.magisk.unblock 10\n"
+"   rm /dev/.magisk.unblock\n"
+"\n"
+
+// Services
+
+"service magisk_daemon /sbin/magisk --daemon\n"
+"   user root\n"
+"   seclabel u:r:su:s0\n"
+"\n"
+
+"service magisk_pfs /sbin/magisk --post-fs\n"
+"   user root\n"
+"   seclabel u:r:su:s0\n"
+"   oneshot\n"
+"\n"
+
+"service magisk_pfsd /sbin/magisk --post-fs-data\n"
+"   user root\n"
+"   seclabel u:r:su:s0\n"
+"   oneshot\n"
+"\n"
+
+"service magisk_service /sbin/magisk  --service\n"
+"   class late_start\n"
+"   user root\n"
+"   seclabel u:r:su:s0\n"
+"   oneshot\n"
+;

jni/include/resetprop.h

@@ -8,12 +8,15 @@
 extern "C" {
 #endif
 
-int init_resetprop();
+int prop_exist(const char *name);
 int setprop(const char *name, const char *value);
 int setprop2(const char *name, const char *value, const int trigger);
 char *getprop(const char *name);
+char *getprop2(const char *name, int persist);
 int deleteprop(const char *name);
+int deleteprop2(const char *name, const int persist);
 int read_prop_file(const char* filename, const int trigger);
+void getprop_all(void (*callback)(const char*, const char*));
 
 #ifdef __cplusplus
 }

jni/include/utils.h

@@ -7,7 +7,6 @@
 #include <stdio.h>
 #include <dirent.h>
 #include <pthread.h>
-#include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 
@@ -18,8 +17,6 @@
 #define UID_SYSTEM (get_system_uid())
 #define UID_RADIO  (get_radio_uid())
 
-extern int quit_signals[];
-
 // xwrap.c
 
 FILE *xfopen(const char *pathname, const char *mode);
@@ -28,19 +25,21 @@ FILE *xfdopen(int fd, const char *mode);
 #define xopen(...) GET_MACRO(__VA_ARGS__, xopen3, xopen2)(__VA_ARGS__)
 int xopen2(const char *pathname, int flags);
 int xopen3(const char *pathname, int flags, mode_t mode);
+int xopenat(int dirfd, const char *pathname, int flags);
 ssize_t xwrite(int fd, const void *buf, size_t count);
 ssize_t xread(int fd, void *buf, size_t count);
 ssize_t xxread(int fd, void *buf, size_t count);
-int xpipe(int pipefd[2]);
+int xpipe2(int pipefd[2], int flags);
 int xsetns(int fd, int nstype);
 DIR *xopendir(const char *name);
+DIR *xfdopendir(int fd);
 struct dirent *xreaddir(DIR *dirp);
 pid_t xsetsid();
 int xsocket(int domain, int type, int protocol);
 int xbind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
 int xconnect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
 int xlisten(int sockfd, int backlog);
-int xaccept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+int xaccept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
 void *xmalloc(size_t size);
 void *xcalloc(size_t nmemb, size_t size);
 void *xrealloc(void *ptr, size_t size);
@@ -53,47 +52,89 @@ int xstat(const char *pathname, struct stat *buf);
 int xlstat(const char *pathname, struct stat *buf);
 int xdup2(int oldfd, int newfd);
 ssize_t xreadlink(const char *pathname, char *buf, size_t bufsiz);
+ssize_t xreadlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz);
 int xsymlink(const char *target, const char *linkpath);
 int xmount(const char *source, const char *target,
 	const char *filesystemtype, unsigned long mountflags,
 	const void *data);
 int xumount(const char *target);
 int xumount2(const char *target, int flags);
-int xchmod(const char *pathname, mode_t mode);
 int xrename(const char *oldpath, const char *newpath);
 int xmkdir(const char *pathname, mode_t mode);
+int xmkdir_p(const char *pathname, mode_t mode);
+int xmkdirat(int dirfd, const char *pathname, mode_t mode);
 void *xmmap(void *addr, size_t length, int prot, int flags,
 	int fd, off_t offset);
 ssize_t xsendfile(int out_fd, int in_fd, off_t *offset, size_t count);
-int xmkdir_p(const char *pathname, mode_t mode);
+pid_t xfork();
 
 // misc.c
 
+extern int quit_signals[];
+
 unsigned get_shell_uid();
 unsigned get_system_uid();
 unsigned get_radio_uid();
 int check_data();
 int file_to_vector(const char* filename, struct vector *v);
 int vector_to_file(const char* filename, struct vector *v);
-int isNum(const char *s);
 ssize_t fdgets(char *buf, size_t size, int fd);
 void ps(void (*func)(int));
 void ps_filter_proc_name(const char *filter, void (*func)(int));
-int create_links(const char *bin, const char *path);
 void unlock_blocks();
 void setup_sighandlers(void (*handler)(int));
-int run_command(int err, int *fd, const char *path, char *const argv[]);
-int mkdir_p(const char *pathname, mode_t mode);
+int exec_command(int err, int *fd, void (*setupenv)(struct vector*), const char *argv0, ...);
+int exec_command_sync(char *const argv0, ...);
 int bind_mount(const char *from, const char *to);
-int open_new(const char *filename);
-int cp_afc(const char *source, const char *target);
-int clone_dir(const char *source, const char *target);
-int rm_rf(const char *target);
-void clone_attr(const char *source, const char *target);
 void get_client_cred(int fd, struct ucred *cred);
+int switch_mnt_ns(int pid);
+int fork_dont_care();
+
+// file.c
+
+extern char **excl_list;
+
+struct file_attr {
+	struct stat st;
+	char con[128];
+};
+
+int fd_getpath(int fd, char *path, size_t size);
+int mkdir_p(const char *pathname, mode_t mode);
+void rm_rf(const char *path);
+void frm_rf(int dirfd);
+void mv_f(const char *source, const char *destination);
+void mv_dir(int src, int dest);
+void cp_afc(const char *source, const char *destination);
+void clone_dir(int src, int dest);
+int getattr(const char *path, struct file_attr *a);
+int getattrat(int dirfd, const char *pathname, struct file_attr *a);
+int fgetattr(int fd, struct file_attr *a);
+int setattr(const char *path, struct file_attr *a);
+int setattrat(int dirfd, const char *pathname, struct file_attr *a);
+int fsetattr(int fd, struct file_attr *a);
+void fclone_attr(const int sourcefd, const int targetfd);
+void clone_attr(const char *source, const char *target);
+void restorecon(int dirfd, int force);
+void mmap_ro(const char *filename, void **buf, size_t *size);
+void mmap_rw(const char *filename, void **buf, size_t *size);
+void full_read(int fd, void **buf, size_t *size);
+void write_zero(int fd, size_t size);
+void mem_align(size_t *pos, size_t align);
+void file_align(int fd, size_t align, int out);
+
+// img.c
+
+#define round_size(a) ((((a) / 32) + 2) * 32)
+#define SOURCE_TMP "/dev/source"
+#define TARGET_TMP "/dev/target"
+
 int create_img(const char *img, int size);
 int get_img_size(const char *img, int *used, int *total);
 int resize_img(const char *img, int size);
-int switch_mnt_ns(int pid);
+char *mount_image(const char *img, const char *target);
+void umount_image(const char *target, const char *device);
+int merge_img(const char *source, const char *target);
+void trim_img(const char *img);
 
 #endif

jni/include/vector.h

@@ -32,4 +32,6 @@ struct vector *vec_dup(struct vector *v);
 	e = v ? (v)->data[(v)->size - 1] : NULL; \
 	for (size_t _ = (v)->size; v && _ > 0; --_, e = (v)->data[_ - 1])
 
-#endif
+#define vec_cur(v) vec_entry(v)[_]
+
+#endif

jni/magiskboot/Android.mk

@@ -1,31 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := magiskboot
-LOCAL_STATIC_LIBRARIES := libz liblzma liblz4 libbz2
-LOCAL_C_INCLUDES := \
-	jni/utils \
-	jni/ndk-compression/zlib/ \
-	jni/ndk-compression/xz/src/liblzma/api/ \
-	jni/ndk-compression/lz4/lib/ \
-	jni/ndk-compression/bzip2/
-
-LOCAL_SRC_FILES := \
-	main.c \
-	unpack.c \
-	repack.c \
-	hexpatch.c \
-	parseimg.c \
-	compress.c \
-	utils.c \
-	cpio.c \
-	sha1.c \
-	../utils/xwrap.c \
-	../utils/vector.c
-LOCAL_CFLAGS += -DZLIB_CONST
-include $(BUILD_EXECUTABLE)
-
-include jni/ndk-compression/zlib/Android.mk
-include jni/ndk-compression/xz/src/liblzma/Android.mk
-include jni/ndk-compression/lz4/lib/Android.mk
-include jni/ndk-compression/bzip2/Android.mk

jni/magiskboot/bootimg.c

@@ -0,0 +1,315 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+#include "bootimg.h"
+#include "magiskboot.h"
+#include "utils.h"
+#include "logging.h"
+
+static void dump(void *buf, size_t size, const char *filename) {
+	int fd = creat(filename, 0644);
+	xwrite(fd, buf, size);
+	close(fd);
+}
+
+static size_t restore(const char *filename, int fd) {
+	int ifd = xopen(filename, O_RDONLY);
+	size_t size = lseek(ifd, 0, SEEK_END);
+	lseek(ifd, 0, SEEK_SET);
+	xsendfile(fd, ifd, NULL, size);
+	close(ifd);
+	return size;
+}
+
+static void restore_buf(int fd, const void *buf, size_t size) {
+	xwrite(fd, buf, size);
+}
+
+static void print_hdr(const boot_img_hdr *hdr) {
+	fprintf(stderr, "KERNEL [%d] @ 0x%08x\n", hdr->kernel_size, hdr->kernel_addr);
+	fprintf(stderr, "RAMDISK [%d] @ 0x%08x\n", hdr->ramdisk_size, hdr->ramdisk_addr);
+	fprintf(stderr, "SECOND [%d] @ 0x%08x\n", hdr->second_size, hdr->second_addr);
+	fprintf(stderr, "EXTRA [%d] @ 0x%08x\n", hdr->extra_size, hdr->tags_addr);
+	fprintf(stderr, "PAGESIZE [%d]\n", hdr->page_size);
+	if (hdr->os_version != 0) {
+		int a,b,c,y,m = 0;
+		int os_version, os_patch_level;
+		os_version = hdr->os_version >> 11;
+		os_patch_level = hdr->os_version & 0x7ff;
+
+		a = (os_version >> 14) & 0x7f;
+		b = (os_version >> 7) & 0x7f;
+		c = os_version & 0x7f;
+		fprintf(stderr, "OS_VERSION [%d.%d.%d]\n", a, b, c);
+
+		y = (os_patch_level >> 4) + 2000;
+		m = os_patch_level & 0xf;
+		fprintf(stderr, "PATCH_LEVEL [%d-%02d]\n", y, m);
+	}
+	fprintf(stderr, "NAME [%s]\n", hdr->name);
+	fprintf(stderr, "CMDLINE [%s]\n", hdr->cmdline);
+	fprintf(stderr, "\n");
+}
+
+int parse_img(void *orig, size_t size, boot_img *boot) {
+	void *base, *end;
+	size_t pos = 0;
+	int ret = 0;
+	memset(boot, 0, sizeof(*boot));
+	for(base = orig, end = orig + size; base < end; base += 256, size -= 256) {
+		switch (check_type(base)) {
+		case CHROMEOS:
+			// The caller should know it's chromeos, as it needs additional signing
+			ret = 2;
+			continue;
+		case ELF32:
+			exit(3);
+		case ELF64:
+			exit(4);
+		case AOSP:
+			// Read the header
+			memcpy(&boot->hdr, base, sizeof(boot->hdr));
+			pos += boot->hdr.page_size;
+
+			print_hdr(&boot->hdr);
+
+			boot->kernel = base + pos;
+			pos += boot->hdr.kernel_size;
+			mem_align(&pos, boot->hdr.page_size);
+
+			boot->ramdisk = base + pos;
+			pos += boot->hdr.ramdisk_size;
+			mem_align(&pos, boot->hdr.page_size);
+
+			if (boot->hdr.second_size) {
+				boot->second = base + pos;
+				pos += boot->hdr.second_size;
+				mem_align(&pos, boot->hdr.page_size);
+			}
+
+			if (boot->hdr.extra_size) {
+				boot->extra = base + pos;
+				pos += boot->hdr.extra_size;
+				mem_align(&pos, boot->hdr.page_size);
+			}
+
+			if (pos < size) {
+				boot->tail = base + pos;
+				boot->tail_size = end - base - pos;
+			}
+
+			// Search for dtb in kernel
+			for (int i = 0; i < boot->hdr.kernel_size; ++i) {
+				if (memcmp(boot->kernel + i, DTB_MAGIC, 4) == 0) {
+					boot->dtb = boot->kernel + i;
+					boot->dt_size = boot->hdr.kernel_size - i;
+					boot->hdr.kernel_size = i;
+					fprintf(stderr, "DTB [%d]\n", boot->dt_size);
+				}
+			}
+
+			boot->ramdisk_type = check_type(boot->ramdisk);
+			boot->kernel_type = check_type(boot->kernel);
+
+			// Check MTK
+			if (boot->kernel_type == MTK) {
+				fprintf(stderr, "MTK_KERNEL_HDR [512]\n");
+				boot->flags |= MTK_KERNEL;
+				memcpy(&boot->mtk_kernel_hdr, boot->kernel, sizeof(mtk_hdr));
+				boot->kernel += 512;
+				boot->hdr.kernel_size -= 512;
+				boot->kernel_type = check_type(boot->kernel);
+			}
+			if (boot->ramdisk_type == MTK) {
+				fprintf(stderr, "MTK_RAMDISK_HDR [512]\n");
+				boot->flags |= MTK_RAMDISK;
+				memcpy(&boot->mtk_ramdisk_hdr, boot->ramdisk, sizeof(mtk_hdr));
+				boot->ramdisk += 512;
+				boot->hdr.ramdisk_size -= 512;
+				boot->ramdisk_type = check_type(boot->ramdisk);
+			}
+
+			char fmt[16];
+
+			get_type_name(boot->kernel_type, fmt);
+			fprintf(stderr, "KERNEL_FMT [%s]\n", fmt);
+			get_type_name(boot->ramdisk_type, fmt);
+			fprintf(stderr, "RAMDISK_FMT [%s]\n", fmt);
+			fprintf(stderr, "\n");
+
+			return ret;
+		default:
+			continue;
+		}
+	}
+	LOGE("No boot image magic found!\n");
+	return 1;
+}
+
+void unpack(const char* image) {
+	size_t size;
+	void *orig;
+	mmap_ro(image, &orig, &size);
+	int fd;
+	boot_img boot;
+
+	// Parse image
+	fprintf(stderr, "Parsing boot image: [%s]\n\n", image);
+	int ret = parse_img(orig, size, &boot);
+
+	// Dump kernel
+	if (COMPRESSED(boot.kernel_type)) {
+		fd = creat(KERNEL_FILE, 0644);
+		decomp(boot.kernel_type, fd, boot.kernel, boot.hdr.kernel_size);
+		close(fd);
+	} else {
+		dump(boot.kernel, boot.hdr.kernel_size, KERNEL_FILE);
+	}
+
+	if (boot.dt_size) {
+		// Dump dtb
+		dump(boot.dtb, boot.dt_size, DTB_FILE);
+	}
+
+	// Dump ramdisk
+	if (COMPRESSED(boot.ramdisk_type)) {
+		fd = creat(RAMDISK_FILE, 0644);
+		decomp(boot.ramdisk_type, fd, boot.ramdisk, boot.hdr.ramdisk_size);
+		close(fd);
+	} else {
+		dump(boot.ramdisk, boot.hdr.ramdisk_size, RAMDISK_FILE ".raw");
+		LOGE("Unknown ramdisk format! Dumped to %s\n", RAMDISK_FILE ".raw");
+	}
+
+	if (boot.hdr.second_size) {
+		// Dump second
+		dump(boot.second, boot.hdr.second_size, SECOND_FILE);
+	}
+
+	if (boot.hdr.extra_size) {
+		// Dump extra
+		dump(boot.extra, boot.hdr.extra_size, EXTRA_FILE);
+	}
+
+	munmap(orig, size);
+	exit(ret);
+}
+
+void repack(const char* orig_image, const char* out_image) {
+	size_t size;
+	void *orig;
+	boot_img boot;
+
+	// There are possible two MTK headers
+	size_t mtk_kernel_off, mtk_ramdisk_off;
+
+	// Load original image
+	mmap_ro(orig_image, &orig, &size);
+
+	// Parse original image
+	fprintf(stderr, "Parsing boot image: [%s]\n\n", orig_image);
+	parse_img(orig, size, &boot);
+
+	fprintf(stderr, "Repack to boot image: [%s]\n\n", out_image);
+
+	// Create new image
+	int fd = creat(out_image, 0644);
+
+	// Skip a page for header
+	write_zero(fd, boot.hdr.page_size);
+
+	if (boot.flags & MTK_KERNEL) {
+		// Record position and skip MTK header
+		mtk_kernel_off = lseek(fd, 0, SEEK_CUR);
+		write_zero(fd, 512);
+	}
+	if (COMPRESSED(boot.kernel_type)) {
+		size_t raw_size;
+		void *kernel_raw;
+		mmap_ro(KERNEL_FILE, &kernel_raw, &raw_size);
+		boot.hdr.kernel_size = comp(boot.kernel_type, fd, kernel_raw, raw_size);
+		munmap(kernel_raw, raw_size);
+	} else {
+		boot.hdr.kernel_size = restore(KERNEL_FILE, fd);
+	}
+	// Restore dtb
+	if (boot.dt_size && access(DTB_FILE, R_OK) == 0) {
+		boot.hdr.kernel_size += restore(DTB_FILE, fd);
+	}
+	file_align(fd, boot.hdr.page_size, 1);
+
+	if (boot.flags & MTK_RAMDISK) {
+		// Record position and skip MTK header
+		mtk_ramdisk_off = lseek(fd, 0, SEEK_CUR);
+		write_zero(fd, 512);
+	}
+	if (access(RAMDISK_FILE, R_OK) == 0) {
+		// If we found raw cpio, compress to original format
+		size_t cpio_size;
+		void *cpio;
+		mmap_ro(RAMDISK_FILE, &cpio, &cpio_size);
+		boot.hdr.ramdisk_size = comp(boot.ramdisk_type, fd, cpio, cpio_size);
+		munmap(cpio, cpio_size);
+	} else {
+		// Find compressed ramdisk
+		char name[PATH_MAX];
+		int found = 0;
+		for (int i = 0; SUP_EXT_LIST[i]; ++i) {
+			sprintf(name, "%s.%s", RAMDISK_FILE, SUP_EXT_LIST[i]);
+			if (access(name, R_OK) == 0) {
+				found = 1;
+				break;
+			}
+		}
+		if (!found)
+			LOGE("No ramdisk exists!\n");
+		boot.hdr.ramdisk_size = restore(name, fd);
+	}
+	file_align(fd, boot.hdr.page_size, 1);
+
+	// Restore second
+	if (boot.hdr.second_size && access(SECOND_FILE, R_OK) == 0) {
+		boot.hdr.second_size = restore(SECOND_FILE, fd);
+		file_align(fd, boot.hdr.page_size, 1);
+	}
+
+	// Restore extra
+	if (boot.hdr.extra_size && access(EXTRA_FILE, R_OK) == 0) {
+		boot.hdr.extra_size = restore(EXTRA_FILE, fd);
+		file_align(fd, boot.hdr.page_size, 1);
+	}
+
+	// Check tail info, currently only for LG Bump and Samsung SEANDROIDENFORCE
+	if (boot.tail_size >= 16) {
+		if (memcmp(boot.tail, "SEANDROIDENFORCE", 16) == 0 ||
+			memcmp(boot.tail, LG_BUMP_MAGIC, 16) == 0 ) {
+			restore_buf(fd, boot.tail, 16);
+		}
+	}
+
+	// Write MTK headers back
+	if (boot.flags & MTK_KERNEL) {
+		lseek(fd, mtk_kernel_off, SEEK_SET);
+		boot.mtk_kernel_hdr.size = boot.hdr.kernel_size;
+		boot.hdr.kernel_size += 512;
+		restore_buf(fd, &boot.mtk_kernel_hdr, sizeof(mtk_hdr));
+	}
+	if (boot.flags & MTK_RAMDISK) {
+		lseek(fd, mtk_ramdisk_off, SEEK_SET);
+		boot.mtk_ramdisk_hdr.size = boot.hdr.ramdisk_size;
+		boot.hdr.ramdisk_size += 512;
+		restore_buf(fd, &boot.mtk_ramdisk_hdr, sizeof(mtk_hdr));
+	}
+	// Main header
+	lseek(fd, 0, SEEK_SET);
+	restore_buf(fd, &boot.hdr, sizeof(boot.hdr));
+
+	// Print new image info
+	print_hdr(&boot.hdr);
+
+	munmap(orig, size);
+	close(fd);
+}
+

jni/magiskboot/bootimg.h

@@ -2,20 +2,21 @@
 **
 ** Copyright 2007, 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 
+** 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 
+**     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 
+** 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.
 */
 
 #include <stdint.h>
+#include "types.h"
 
 #ifndef _BOOT_IMAGE_H_
 #define _BOOT_IMAGE_H_
@@ -43,7 +44,7 @@ struct boot_img_hdr
 
     uint32_t tags_addr;    /* physical addr for kernel tags */
     uint32_t page_size;    /* flash page size we assume */
-    uint32_t dt_size;      /* device tree in bytes */
+    uint32_t extra_size;   /* extra blob size in bytes */
 
     /* operating system version and security patch level; for
      * version "A.B.C" and patch level "Y-M-D":
@@ -64,22 +65,22 @@ struct boot_img_hdr
 } __attribute__((packed));
 
 /*
-** +-----------------+ 
+** +-----------------+
 ** | boot header     | 1 page
 ** +-----------------+
-** | kernel          | n pages  
+** | kernel          | n pages
 ** +-----------------+
-** | ramdisk         | m pages  
+** | ramdisk         | m pages
 ** +-----------------+
 ** | second stage    | o pages
 ** +-----------------+
-** | device tree     | p pages
+** | extra blobs     | p pages
 ** +-----------------+
 **
 ** n = (kernel_size + page_size - 1) / page_size
 ** m = (ramdisk_size + page_size - 1) / page_size
 ** o = (second_size + page_size - 1) / page_size
-** p = (dt_size + page_size - 1) / page_size
+** p = (extra_size + page_size - 1) / page_size
 **
 ** 0. all entities are page_size aligned in flash
 ** 1. kernel and ramdisk are required (size != 0)
@@ -99,4 +100,23 @@ typedef struct mtk_hdr {
    uint8_t name[32];    /* The type of the header */
 } mtk_hdr;
 
+// Flags
+#define MTK_KERNEL    0x1
+#define MTK_RAMDISK   0x2
+
+typedef struct boot_img {
+    boot_img_hdr hdr;
+    void *kernel;
+    void *dtb;
+    uint32_t dt_size;
+    void *ramdisk;
+    void *second;
+    void *extra;
+    void *tail;
+    uint32_t tail_size;
+    uint32_t flags;
+    file_t kernel_type, ramdisk_type;
+    mtk_hdr mtk_kernel_hdr, mtk_ramdisk_hdr;
+} boot_img;
+
 #endif

jni/magiskboot/compress.c

@@ -1,93 +1,61 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
 #include <zlib.h>
 #include <lzma.h>
 #include <lz4.h>
 #include <lz4frame.h>
+#include <lz4hc.h>
 #include <bzlib.h>
 
 #include "magiskboot.h"
+#include "logging.h"
+#include "utils.h"
 
-#define windowBits 15
-#define ZLIB_GZIP 16
-#define memLevel 8
 #define CHUNK 0x40000
 
-#define LZ4_HEADER_SIZE 19
-#define LZ4_FOOTER_SIZE 4
-#define LZ4_LEGACY_BLOCKSIZE  0x800000
-
-static void write_file(const int fd, const void *buf, const size_t size, const char *filename) {
-	xwrite(fd, buf, size);
-}
-
-static void report(const int mode, const char* filename) {
-	switch(mode) {
-		case 0:
-			printf("Decompressing to [%s]\n\n", filename);
-			break;
-		default:
-			printf("Compressing to [%s]\n\n", filename);
-			break;
-	}
-}
-
 // Mode: 0 = decode; 1 = encode
-void gzip(int mode, const char* filename, const unsigned char* buf, size_t size) {
-	size_t ret = 0, flush, have, pos = 0;
+size_t gzip(int mode, int fd, const void *buf, size_t size) {
+	size_t ret = 0, have, total = 0;
 	z_stream strm;
 	unsigned char out[CHUNK];
 
-	report(mode, filename);
-	int fd = open_new(filename);
-
 	strm.zalloc = Z_NULL;
 	strm.zfree = Z_NULL;
 	strm.opaque = Z_NULL;
 
 	switch(mode) {
 		case 0:
-			ret = inflateInit2(&strm, windowBits | ZLIB_GZIP);
+			ret = inflateInit2(&strm, 15 | 16);
 			break;
 		case 1:
-			ret = deflateInit2(&strm, 9, Z_DEFLATED, windowBits | ZLIB_GZIP, memLevel, Z_DEFAULT_STRATEGY);
+			ret = deflateInit2(&strm, 9, Z_DEFLATED, 15 | 16, 8, Z_DEFAULT_STRATEGY);
 			break;
-		default:
-			LOGE(1, "Unsupported gzip mode!\n");
 	}
 
 	if (ret != Z_OK)
-		LOGE(1, "Unable to init zlib stream\n");
+		LOGE("Unable to init zlib stream\n");
+
+	strm.next_in = (void *) buf;
+	strm.avail_in = size;
 
 	do {
-		strm.next_in = buf + pos;
-		if (pos + CHUNK >= size) {
-			strm.avail_in = size - pos;
-			flush = Z_FINISH;
-		} else {
-			strm.avail_in = CHUNK;
-			flush = Z_NO_FLUSH;
+		strm.avail_out = CHUNK;
+		strm.next_out = out;
+		switch(mode) {
+			case 0:
+				ret = inflate(&strm, Z_FINISH);
+				break;
+			case 1:
+				ret = deflate(&strm, Z_FINISH);
+				break;
 		}
-		pos += strm.avail_in;
-
-		do {
-			strm.avail_out = CHUNK;
-			strm.next_out = out;
-			switch(mode) {
-				case 0:
-					ret = inflate(&strm, flush);
-					break;
-				case 1:
-					ret = deflate(&strm, flush);
-					break;
-			}
-			if (ret == Z_STREAM_ERROR)
-				LOGE(1, "Error when running gzip\n");
-
-			have = CHUNK - strm.avail_out;
-			write_file(fd, out, have, filename);
-
-		} while (strm.avail_out == 0);
-
-	} while(pos < size);
+		if (ret == Z_STREAM_ERROR)
+			LOGE("Error when running gzip\n");
+		have = CHUNK - strm.avail_out;
+		total += xwrite(fd, out, have);
+	} while (strm.avail_out == 0);
 
 	switch(mode) {
 		case 0:
@@ -97,24 +65,19 @@ void gzip(int mode, const char* filename, const unsigned char* buf, size_t size)
 			deflateEnd(&strm);
 			break;
 	}
-	close(fd);
+	return total;
 }
 
-
 // Mode: 0 = decode xz/lzma; 1 = encode xz; 2 = encode lzma
-void lzma(int mode, const char* filename, const unsigned char* buf, size_t size) {
-	size_t have, pos = 0;
+size_t lzma(int mode, int fd, const void *buf, size_t size) {
+	size_t have, total = 0;
 	lzma_ret ret = 0;
 	lzma_stream strm = LZMA_STREAM_INIT;
 	lzma_options_lzma opt;
-	lzma_action action;
-	unsigned char out[BUFSIZ];
-
-	report(mode, filename);
-	int fd = open_new(filename);
+	unsigned char out[CHUNK];
 
 	// Initialize preset
-	lzma_lzma_preset(&opt, LZMA_PRESET_DEFAULT);
+	lzma_lzma_preset(&opt, 9);
 	lzma_filter filters[] = {
 		{ .id = LZMA_FILTER_LZMA2, .options = &opt },
 		{ .id = LZMA_VLI_UNKNOWN, .options = NULL },
@@ -125,59 +88,43 @@ void lzma(int mode, const char* filename, const unsigned char* buf, size_t size)
 			ret = lzma_auto_decoder(&strm, UINT64_MAX, 0);
 			break;
 		case 1:
-			ret = lzma_stream_encoder(&strm, filters, LZMA_CHECK_CRC64);
+			ret = lzma_stream_encoder(&strm, filters, LZMA_CHECK_CRC32);
 			break;
 		case 2:
 			ret = lzma_alone_encoder(&strm, &opt);
 			break;
-		default:
-			LOGE(1, "Unsupported lzma mode!\n");
 	}
 
 
 	if (ret != LZMA_OK)
-		LOGE(1, "Unable to init lzma stream\n");
+		LOGE("Unable to init lzma stream\n");
+
+	strm.next_in = buf;
+	strm.avail_in = size;
 
 	do {
-		strm.next_in = buf + pos;
-		if (pos + BUFSIZ >= size) {
-			strm.avail_in = size - pos;
-			action = LZMA_FINISH;
-		} else {
-			strm.avail_in = BUFSIZ;
-			action = LZMA_RUN;
-		}
-		pos += strm.avail_in;
-
-		do {
-			strm.avail_out = BUFSIZ;
-			strm.next_out = out;
-			ret = lzma_code(&strm, action);
-			have = BUFSIZ - strm.avail_out;
-			write_file(fd, out, have, filename);
-		} while (strm.avail_out == 0 && ret == LZMA_OK);
-
+		strm.avail_out = CHUNK;
+		strm.next_out = out;
+		ret = lzma_code(&strm, LZMA_FINISH);
 		if (ret != LZMA_OK && ret != LZMA_STREAM_END)
-			LOGE(1, "LZMA error %d!\n", ret);
-
-	} while (pos < size);
+			LOGE("LZMA error %d!\n", ret);
+		have = CHUNK - strm.avail_out;
+		total += xwrite(fd, out, have);
+	} while (strm.avail_out == 0);
 
 	lzma_end(&strm);
-	close(fd);
+	return total;
 }
 
 // Mode: 0 = decode; 1 = encode
-void lz4(int mode, const char* filename, const unsigned char* buf, size_t size) {
+size_t lz4(int mode, int fd, const void *buf, size_t size) {
 	LZ4F_decompressionContext_t dctx;
 	LZ4F_compressionContext_t cctx;
 	LZ4F_frameInfo_t info;
 
-	size_t outCapacity, avail_in, ret = 0, pos = 0;
+	size_t blockSize, outCapacity, avail_in, ret = 0, pos = 0, total = 0;
 	size_t have, read;
-	unsigned char *out = NULL;
-
-	report(mode, filename);
-	int fd = open_new(filename);
+	void *out = NULL;
 
 	// Initialize context
 	switch(mode) {
@@ -187,21 +134,20 @@ void lz4(int mode, const char* filename, const unsigned char* buf, size_t size)
 		case 1:
 			ret = LZ4F_createCompressionContext(&cctx, LZ4F_VERSION);
 			break;
-		default:
-			LOGE(1, "Unsupported lz4 mode!\n");
 	}
-	
+
 	if (LZ4F_isError(ret))
-		LOGE(1, "Context creation error: %s\n", LZ4F_getErrorName(ret));
+		LOGE("Context creation error: %s\n", LZ4F_getErrorName(ret));
 
 	// Allocate out buffer
+	blockSize = 1 << 22;
 	switch(mode) {
 		case 0:
 			// Read header
-			read = CHUNK;
+			read = blockSize;
 			ret = LZ4F_getFrameInfo(dctx, &info, buf, &read);
 			if (LZ4F_isError(ret))
-				LOGE(1, "LZ4F_getFrameInfo error: %s\n", LZ4F_getErrorName(ret));
+				LOGE("LZ4F_getFrameInfo error: %s\n", LZ4F_getErrorName(ret));
 			switch (info.blockSizeID) {
 				case LZ4F_default:
 				case LZ4F_max64KB:  outCapacity = 1 << 16; break;
@@ -209,12 +155,12 @@ void lz4(int mode, const char* filename, const unsigned char* buf, size_t size)
 				case LZ4F_max1MB:   outCapacity = 1 << 20; break;
 				case LZ4F_max4MB:   outCapacity = 1 << 22; break;
 				default:
-					LOGE(1, "Impossible unless more block sizes are allowed\n");
+					LOGE("Impossible unless more block sizes are allowed\n");
 			}
 			pos += read;
 			break;
 		case 1:
-			outCapacity = LZ4F_compressBound(CHUNK, NULL) + LZ4_HEADER_SIZE + LZ4_FOOTER_SIZE;
+			outCapacity = LZ4F_compressFrameBound(blockSize, NULL);
 			break;
 	}
 
@@ -222,23 +168,31 @@ void lz4(int mode, const char* filename, const unsigned char* buf, size_t size)
 
 	// Write header
 	if (mode == 1) {
-		have = ret = LZ4F_compressBegin(cctx, out, size, NULL);
+		LZ4F_preferences_t prefs;
+		memset(&prefs, 0, sizeof(prefs));
+		prefs.autoFlush = 1;
+		prefs.compressionLevel = 9;
+		prefs.frameInfo.blockMode = 1;
+		prefs.frameInfo.blockSizeID = 7;
+		prefs.frameInfo.contentChecksumFlag = 1;
+		have = ret = LZ4F_compressBegin(cctx, out, size, &prefs);
 		if (LZ4F_isError(ret))
-			LOGE(1, "Failed to start compression: error %s\n", LZ4F_getErrorName(ret));
-		write_file(fd, out, have, filename);
+			LOGE("Failed to start compression: error %s\n", LZ4F_getErrorName(ret));
+		total += xwrite(fd, out, have);
 	}
 
 	do {
-		if (pos + CHUNK >= size) {
+		if (pos + blockSize >= size) {
 			avail_in = size - pos;
 		} else {
-			avail_in = CHUNK;
+			avail_in = blockSize;
 		}
 
 		do {
 			switch(mode) {
 				case 0:
-					have = outCapacity, read = avail_in;
+					have = outCapacity;
+					read = avail_in;
 					ret = LZ4F_decompress(dctx, out, &have, buf + pos, &read, NULL);
 					break;
 				case 1:
@@ -247,9 +201,9 @@ void lz4(int mode, const char* filename, const unsigned char* buf, size_t size)
 					break;
 			}
 			if (LZ4F_isError(ret))
-				LOGE(1, "LZ4 coding error: %s\n", LZ4F_getErrorName(ret));
+				LOGE("LZ4 coding error: %s\n", LZ4F_getErrorName(ret));
 
-			write_file(fd, out, have, filename);
+			total += xwrite(fd, out, have);
 			// Update status
 			pos += read;
 			avail_in -= read;
@@ -264,27 +218,24 @@ void lz4(int mode, const char* filename, const unsigned char* buf, size_t size)
 		case 1:
 			have = ret = LZ4F_compressEnd(cctx, out, outCapacity, NULL);
 			if (LZ4F_isError(ret))
-				LOGE(1, "Failed to end compression: error %s\n", LZ4F_getErrorName(ret));
+				LOGE("Failed to end compression: error %s\n", LZ4F_getErrorName(ret));
 
-			write_file(fd, out, have, filename);
+			total += xwrite(fd, out, have);
 
 			LZ4F_freeCompressionContext(cctx);
 			break;
 	}
 
 	free(out);
-	close(fd);
+	return total;
 }
 
 // Mode: 0 = decode; 1 = encode
-void bzip2(int mode, const char* filename, const unsigned char* buf, size_t size) {
-	size_t ret = 0, action, have, pos = 0;
+size_t bzip2(int mode, int fd, const void* buf, size_t size) {
+	size_t ret = 0, have, total = 0;
 	bz_stream strm;
 	char out[CHUNK];
 
-	report(mode, filename);
-	int fd = open_new(filename);
-
 	strm.bzalloc = NULL;
 	strm.bzfree = NULL;
 	strm.opaque = NULL;
@@ -296,42 +247,28 @@ void bzip2(int mode, const char* filename, const unsigned char* buf, size_t size
 		case 1:
 			ret = BZ2_bzCompressInit(&strm, 9, 0, 0);
 			break;
-		default:
-			LOGE(1, "Unsupported bzip2 mode!\n");
 	}
 
 	if (ret != BZ_OK)
-		LOGE(1, "Unable to init bzlib stream\n");
+		LOGE("Unable to init bzlib stream\n");
+
+	strm.next_in = (void *) buf;
+	strm.avail_in = size;
 
 	do {
-		strm.next_in = (char *) buf + pos;
-		if (pos + CHUNK >= size) {
-			strm.avail_in = size - pos;
-			action = BZ_FINISH;
-		} else {
-			strm.avail_in = CHUNK;
-			action = BZ_RUN;
+		strm.avail_out = CHUNK;
+		strm.next_out = out;
+		switch(mode) {
+			case 0:
+				ret = BZ2_bzDecompress(&strm);
+				break;
+			case 1:
+				ret = BZ2_bzCompress(&strm, BZ_FINISH);
+				break;
 		}
-		pos += strm.avail_in;
-
-		do {
-			strm.avail_out = CHUNK;
-			strm.next_out = out;
-			switch(mode) {
-				case 0:
-					ret = BZ2_bzDecompress(&strm);
-					break;
-				case 1:
-					ret = BZ2_bzCompress(&strm, action);
-					break;
-			}
-
-			have = CHUNK - strm.avail_out;
-			write_file(fd, out, have, filename);
-
-		} while (strm.avail_out == 0);
-
-	} while(pos < size);
+		have = CHUNK - strm.avail_out;
+		total += xwrite(fd, out, have);
+	} while (strm.avail_out == 0);
 
 	switch(mode) {
 		case 0:
@@ -341,20 +278,17 @@ void bzip2(int mode, const char* filename, const unsigned char* buf, size_t size
 			BZ2_bzCompressEnd(&strm);
 			break;
 	}
-	close(fd);
+	return total;
 }
 
+#define LZ4_LEGACY_BLOCKSIZE  0x800000
+
 // Mode: 0 = decode; 1 = encode
-void lz4_legacy(int mode, const char* filename, const unsigned char* buf, size_t size) {
+size_t lz4_legacy(int mode, int fd, const void* buf, size_t size) {
 	size_t pos = 0;
 	int have;
 	char *out;
-	unsigned block_size, insize;
-	unsigned char block_size_le[4];
-
-
-	report(mode, filename);
-	int fd = open_new(filename);
+	unsigned block_size, insize, total = 0;
 
 	switch(mode) {
 		case 0:
@@ -365,25 +299,21 @@ void lz4_legacy(int mode, const char* filename, const unsigned char* buf, size_t
 		case 1:
 			out = xmalloc(LZ4_COMPRESSBOUND(LZ4_LEGACY_BLOCKSIZE));
 			// Write magic
-			write_file(fd, "\x02\x21\x4c\x18", 4, filename);
+			total += xwrite(fd, "\x02\x21\x4c\x18", 4);
 			break;
-		default:
-			LOGE(1, "Unsupported lz4_legacy mode!\n");
 	}
 
 	do {
 		switch(mode) {
 			case 0:
-				block_size = buf[pos];
-				block_size += (buf[pos + 1]<<8);
-				block_size += (buf[pos + 2]<<16);
-				block_size += ((unsigned)buf[pos + 3])<<24;
+				// Read block size
+				block_size = *(unsigned *)(buf + pos);
 				pos += 4;
 				if (block_size > LZ4_COMPRESSBOUND(LZ4_LEGACY_BLOCKSIZE))
-					LOGE(1, "lz4_legacy block size too large!\n");
-				have = LZ4_decompress_safe((const char*) (buf + pos), out, block_size, LZ4_LEGACY_BLOCKSIZE);
+					goto done;
+				have = LZ4_decompress_safe(buf + pos, out, block_size, LZ4_LEGACY_BLOCKSIZE);
 				if (have < 0)
-					LOGE(1, "Cannot decode lz4_legacy block\n");
+					LOGE("Cannot decode lz4_legacy block\n");
 				pos += block_size;
 				break;
 			case 1:
@@ -391,164 +321,158 @@ void lz4_legacy(int mode, const char* filename, const unsigned char* buf, size_t
 					insize = size - pos;
 				else
 					insize = LZ4_LEGACY_BLOCKSIZE;
-				have = LZ4_compress_default((const char*) (buf + pos), out, insize, LZ4_COMPRESSBOUND(LZ4_LEGACY_BLOCKSIZE));
+				have = LZ4_compress_HC(buf + pos, out, insize, LZ4_COMPRESSBOUND(LZ4_LEGACY_BLOCKSIZE), 9);
 				if (have == 0)
-					LOGE(1, "lz4_legacy compression error\n");
+					LOGE("lz4_legacy compression error\n");
 				pos += insize;
-				block_size_le[0] = (unsigned char)have;
-				block_size_le[1] = (unsigned char)(have >> 8);
-				block_size_le[2] = (unsigned char)(have >> 16);
-				block_size_le[3] = (unsigned char)(have >> 24);
-				write_file(fd, block_size_le, 4, filename);
+				// Write block size
+				total += xwrite(fd, &have, sizeof(have));
 				break;
 		}
 		// Write main data
-		write_file(fd, out, have, filename);
+		total += xwrite(fd, out, have);
 	} while(pos < size);
 
+done:
+	if (mode == 1) {
+		// Append original size to output
+		unsigned uncomp = size;
+		xwrite(fd, &uncomp, sizeof(uncomp));
+	}
 	free(out);
-	close(fd);
+	return total;
 }
 
-int decomp(file_t type, const char *to, const unsigned char *from, size_t size) {
+long long decomp(file_t type, int to, const void *from, size_t size) {
 	switch (type) {
 		case GZIP:
-			gzip(0, to, from, size);
-			break;
+			return gzip(0, to, from, size);
 		case XZ:
-			lzma(0, to, from, size);
-			break;
+			return lzma(0, to, from, size);
 		case LZMA:
-			lzma(0, to, from, size);
-			break;
+			return lzma(0, to, from, size);
 		case BZIP2:
-			bzip2(0, to, from, size);
-			break;
+			return bzip2(0, to, from, size);
 		case LZ4:
-			lz4(0, to, from, size);
-			break;
+			return lz4(0, to, from, size);
 		case LZ4_LEGACY:
-			lz4_legacy(0, to, from, size);
-			break;
+			return lz4_legacy(0, to, from, size);
 		default:
 			// Unsupported
-			return 1;
+			return -1;
 	}
-	return 0;
 }
 
-// Output will be to.ext
-int comp(file_t type, const char *to, const unsigned char *from, size_t size) {
-	char name[PATH_MAX];
-	const char *ext = strrchr(to, '.');
-	if (ext == NULL) ext = to;
-	strcpy(name, to);
+long long comp(file_t type, int to, const void *from, size_t size) {
 	switch (type) {
 		case GZIP:
-			if (strcmp(ext, ".gz") != 0)
-				sprintf(name, "%s.%s", to, "gz");
-			gzip(1, name, from, size);
-			break;
+			return gzip(1, to, from, size);
 		case XZ:
-			if (strcmp(ext, ".xz") != 0)
-				sprintf(name, "%s.%s", to, "xz");
-			lzma(1, name, from, size);
-			break;
+			return lzma(1, to, from, size);
 		case LZMA:
-			if (strcmp(ext, ".lzma") != 0)
-				sprintf(name, "%s.%s", to, "lzma");
-			lzma(2, name, from, size);
-			break;
+			return lzma(2, to, from, size);
 		case BZIP2:
-			if (strcmp(ext, ".bz2") != 0)
-				sprintf(name, "%s.%s", to, "bz2");
-			bzip2(1, name, from, size);
-			break;
+			return bzip2(1, to, from, size);
 		case LZ4:
-			if (strcmp(ext, ".lz4") != 0)
-				sprintf(name, "%s.%s", to, "lz4");
-			lz4(1, name, from, size);
-			break;
+			return lz4(1, to, from, size);
 		case LZ4_LEGACY:
-			if (strcmp(ext, ".lz4") != 0)
-				sprintf(name, "%s.%s", to, "lz4");
-			lz4_legacy(1, name, from, size);
-			break;
+			return lz4_legacy(1, to, from, size);
 		default:
 			// Unsupported
-			return 1;
+			return -1;
 	}
-	return 0;
 }
 
+/*
+ * Below are utility functions for commandline
+ */
+
 void decomp_file(char *from, const char *to) {
-	int ok = 1;
-	unsigned char *file;
-	size_t size;
-	mmap_ro(from, &file, &size);
+	int strip = 1;
+	void *file;
+	size_t size = 0;
+	if (strcmp(from, "-") == 0)
+		full_read(STDIN_FILENO, &file, &size);
+	else
+		mmap_ro(from, &file, &size);
 	file_t type = check_type(file);
 	char *ext;
 	ext = strrchr(from, '.');
-	if (ext == NULL)
-		LOGE(1, "Bad filename extention\n");
-
-	// File type and extension should match
-	switch (type) {
+	if (to == NULL)
+		to = from;
+	if (ext != NULL) {
+		// Strip out a matched file extension
+		switch (type) {
 		case GZIP:
 			if (strcmp(ext, ".gz") != 0)
-				ok = 0;
+				strip = 0;
 			break;
 		case XZ:
 			if (strcmp(ext, ".xz") != 0)
-				ok = 0;
+				strip = 0;
 			break;
 		case LZMA:
 			if (strcmp(ext, ".lzma") != 0)
-				ok = 0;
+				strip = 0;
 			break;
 		case BZIP2:
 			if (strcmp(ext, ".bz2") != 0)
-				ok = 0;
+				strip = 0;
 			break;
 		case LZ4_LEGACY:
 		case LZ4:
 			if (strcmp(ext, ".lz4") != 0)
-				ok = 0;
+				strip = 0;
 			break;
 		default:
-			LOGE(1, "Provided file \'%s\' is not a supported archive format\n", from);
-	}
-	if (ok) {
-		// If all match, strip out the suffix
-		if (!to) {
+			LOGE("Provided file \'%s\' is not a supported archive format\n", from);
+		}
+		if (strip)
 			*ext = '\0';
-			to = from;
-		}
-		decomp(type, to, file, size);
-		if (to == from) {
-			*ext = '.';
-			unlink(from);
-		}
-	} else {
-		LOGE(1, "Bad filename extention \'%s\'\n", ext);
 	}
-	munmap(file, size);
+
+	int fd;
+
+	if (strcmp(to, "-") == 0) {
+		fd = STDOUT_FILENO;
+	} else {
+		fd = creat(to, 0644);
+		fprintf(stderr, "Decompressing to [%s]\n\n", to);
+	}
+
+	decomp(type, fd, file, size);
+	close(fd);
+	if (to == from && ext != NULL) {
+		*ext = '.';
+		unlink(from);
+	}
+	if (strcmp(from, "-") == 0)
+		free(file);
+	else
+		munmap(file, size);
 }
 
 void comp_file(const char *method, const char *from, const char *to) {
 	file_t type;
+	char *ext, dest[PATH_MAX];
 	if (strcmp(method, "gzip") == 0) {
 		type = GZIP;
+		ext = "gz";
 	} else if (strcmp(method, "xz") == 0) {
 		type = XZ;
+		ext = "xz";
 	} else if (strcmp(method, "lzma") == 0) {
 		type = LZMA;
+		ext = "lzma";
 	} else if (strcmp(method, "lz4") == 0) {
 		type = LZ4;
+		ext = "lz4";
 	} else if (strcmp(method, "lz4_legacy") == 0) {
 		type = LZ4_LEGACY;
+		ext = "lz4";
 	} else if (strcmp(method, "bzip2") == 0) {
 		type = BZIP2;
+		ext = "bz2";
 	} else {
 		fprintf(stderr, "Only support following methods: ");
 		for (int i = 0; SUP_LIST[i]; ++i)
@@ -556,14 +480,33 @@ void comp_file(const char *method, const char *from, const char *to) {
 		fprintf(stderr, "\n");
 		exit(1);
 	}
-	unsigned char *file;
+	void *file;
 	size_t size;
-	mmap_ro(from, &file, &size);
-	if (!to)
-		to = from;
-	comp(type, to, file, size);
-	munmap(file, size);
-	if (to == from)
+	if (strcmp(from, "-") == 0)
+		full_read(STDIN_FILENO, &file, &size);
+	else
+		mmap_ro(from, &file, &size);
+	if (to == NULL) {
+		if (strcmp(from, "-") == 0)
+			strcpy(dest, "-");
+		else
+			snprintf(dest, sizeof(dest), "%s.%s", from, ext);
+	} else
+		strcpy(dest, to);
+	int fd;
+	if (strcmp(dest, "-") == 0) {
+		fd = STDOUT_FILENO;
+	} else {
+		fd = creat(dest, 0644);
+		fprintf(stderr, "Compressing to [%s]\n\n", dest);
+	}
+	comp(type, fd, file, size);
+	close(fd);
+	if (strcmp(from, "-") == 0)
+		free(file);
+	else
+		munmap(file, size);
+	if (to == NULL)
 		unlink(from);
 }
 

jni/magiskboot/cpio.c

@@ -1,6 +1,11 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
 #include "magiskboot.h"
 #include "cpio.h"
-#include "vector.h"
+#include "logging.h"
+#include "utils.h"
 
 static uint32_t x8u(char *hex) {
   uint32_t val, inpos = 8, outpos;
@@ -13,12 +18,12 @@ static uint32_t x8u(char *hex) {
   // Because scanf gratuitously treats %*X differently than printf does.
   sprintf(pattern, "%%%dx%%n", inpos);
   sscanf(hex, pattern, &val, &outpos);
-  if (inpos != outpos) LOGE(1, "bad cpio header\n");
+  if (inpos != outpos) LOGE("bad cpio header\n");
 
   return val;
 }
 
-static void cpio_free(cpio_file *f) {
+static void cpio_free(cpio_entry *f) {
 	if (f) {
 		free(f->filename);
 		free(f->data);
@@ -26,46 +31,30 @@ static void cpio_free(cpio_file *f) {
 	}
 }
 
-static void cpio_vec_insert(struct vector *v, cpio_file *n) {
-	cpio_file *f, *t;
-	int shift = 0;
-	// Insert in alphabet order
+static void cpio_vec_insert(struct vector *v, cpio_entry *n) {
+	cpio_entry *f;
 	vec_for_each(v, f) {
-		if (shift) {
-			vec_entry(v)[_] = t;
-			t = f;
-			continue;
-		}
-		t = f;
 		if (strcmp(f->filename, n->filename) == 0) {
 			// Replace, then all is done
 			cpio_free(f);
-			vec_entry(v)[_] = n;
+			vec_cur(v) = n;
 			return;
-		} else if (strcmp(f->filename, n->filename) > 0) {
-			// Insert, then start shifting
-			vec_entry(v)[_] = n;
-			t = f;
-			shift = 1;
 		}
 	}
-	if (shift)
-		vec_push_back(v, t);
-	else
-		vec_push_back(v, n);
+	vec_push_back(v, n);
 }
 
-static int cpio_compare(const void *a, const void *b) {
-	return strcmp((*(cpio_file **) a)->filename, (*(cpio_file **) b)->filename);
+static int cpio_cmp(const void *a, const void *b) {
+	return strcmp((*(cpio_entry **) a)->filename, (*(cpio_entry **) b)->filename);
 }
 
-// Parse cpio file to a vector of cpio_file
+// Parse cpio file to a vector of cpio_entry
 static void parse_cpio(const char *filename, struct vector *v) {
-	printf("Loading cpio: [%s]\n\n", filename);
+	fprintf(stderr, "Loading cpio: [%s]\n\n", filename);
 	int fd = xopen(filename, O_RDONLY);
 	cpio_newc_header header;
-	cpio_file *f;
-	while(read(fd, &header, 110) == 110) {
+	cpio_entry *f;
+	while(xxread(fd, &header, 110) != -1) {
 		f = xcalloc(sizeof(*f), 1);
 		// f->ino = x8u(header.ino);
 		f->mode = x8u(header.mode);
@@ -80,7 +69,7 @@ static void parse_cpio(const char *filename, struct vector *v) {
 		// f->rdevminor = x8u(header.rdevminor);
 		f->namesize = x8u(header.namesize);
 		// f->check = x8u(header.check);
-		f->filename = malloc(f->namesize);
+		f->filename = xmalloc(f->namesize);
 		xxread(fd, f->filename, f->namesize);
 		file_align(fd, 4, 0);
 		if (strcmp(f->filename, ".") == 0 || strcmp(f->filename, "..") == 0) {
@@ -99,16 +88,16 @@ static void parse_cpio(const char *filename, struct vector *v) {
 		vec_push_back(v, f);
 	}
 	close(fd);
-	// Sort by name
-	vec_sort(v, cpio_compare);
 }
 
 static void dump_cpio(const char *filename, struct vector *v) {
-	printf("\nDump cpio: [%s]\n\n", filename);
-	int fd = open_new(filename);
+	fprintf(stderr, "\nDump cpio: [%s]\n\n", filename);
+	int fd = creat(filename, 0644);
 	unsigned inode = 300000;
 	char header[111];
-	cpio_file *f;
+	// Sort by name
+	vec_sort(v, cpio_cmp);
+	cpio_entry *f;
 	vec_for_each(v, f) {
 		if (f->remove) continue;
 		sprintf(header, "070701%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
@@ -143,8 +132,8 @@ static void dump_cpio(const char *filename, struct vector *v) {
 }
 
 static void cpio_vec_destroy(struct vector *v) {
-	// Free each cpio_file
-	cpio_file *f;
+	// Free each cpio_entry
+	cpio_entry *f;
 	vec_for_each(v, f) {
 		cpio_free(f);
 	}
@@ -152,125 +141,141 @@ static void cpio_vec_destroy(struct vector *v) {
 }
 
 static void cpio_rm(int recursive, const char *entry, struct vector *v) {
-	cpio_file *f;
+	cpio_entry *f;
 	vec_for_each(v, f) {
-		if ((recursive && strncmp(f->filename, entry, strlen(entry)) == 0)
-			|| (strcmp(f->filename, entry) == 0) ) {
-			if (!f->remove) {
-				printf("Remove [%s]\n", entry);
-				f->remove = 1;
+		if (strncmp(f->filename, entry, strlen(entry)) == 0) {
+			char next = f->filename[strlen(entry)];
+			if ((recursive && next == '/') || next == '\0') {
+				if (!f->remove) {
+					fprintf(stderr, "Remove [%s]\n", f->filename);
+					f->remove = 1;
+				}
+				if (!recursive) return;
 			}
-			if (!recursive) return;
 		}
 	}
 }
 
 static void cpio_mkdir(mode_t mode, const char *entry, struct vector *v) {
-	cpio_file *f = xcalloc(sizeof(*f), 1);
+	cpio_entry *f = xcalloc(sizeof(*f), 1);
 	f->mode = S_IFDIR | mode;
 	f->namesize = strlen(entry) + 1;
-	f->filename = xmalloc(f->namesize);
-	memcpy(f->filename, entry, f->namesize);
+	f->filename = strdup(entry);
 	cpio_vec_insert(v, f);
-	printf("Create directory [%s] (%04o)\n",entry, mode);
+	fprintf(stderr, "Create directory [%s] (%04o)\n",entry, mode);
 }
 
 static void cpio_add(mode_t mode, const char *entry, const char *filename, struct vector *v) {
 	int fd = xopen(filename, O_RDONLY);
-	cpio_file *f = xcalloc(sizeof(*f), 1);
+	cpio_entry *f = xcalloc(sizeof(*f), 1);
 	f->mode = S_IFREG | mode;
 	f->namesize = strlen(entry) + 1;
-	f->filename = xmalloc(f->namesize);
-	memcpy(f->filename, entry, f->namesize);
+	f->filename = strdup(entry);
 	f->filesize = lseek(fd, 0, SEEK_END);
 	lseek(fd, 0, SEEK_SET);
-	f->data = malloc(f->filesize);
+	f->data = xmalloc(f->filesize);
 	xxread(fd, f->data, f->filesize);
 	close(fd);
 	cpio_vec_insert(v, f);
-	printf("Add entry [%s] (%04o)\n", entry, mode);
+	fprintf(stderr, "Add entry [%s] (%04o)\n", entry, mode);
 }
 
 static void cpio_test(struct vector *v) {
-	#define MAGISK_PATCH  0x1
-	#define OTHER_PATCH 0x2
-	int ret = 0;
-	cpio_file *f;
-	const char *OTHER_LIST[] = { "sbin/launch_daemonsu.sh", "sbin/su", "init.xposed.rc", "init.supersu.rc", NULL };
+	#define STOCK_BOOT      0x0
+	#define MAGISK_PATCH    0x1
+	#define OTHER_PATCH     0x2
+	int ret = STOCK_BOOT;
+	cpio_entry *f;
+	const char *OTHER_LIST[] = { "sbin/launch_daemonsu.sh", "sbin/su", "init.xposed.rc", "boot/sbin/launch_daemonsu.sh", NULL };
+	const char *MAGISK_LIST[] = { ".backup/.magisk", "init.magisk.rc", "overlay/init.magisk.rc", NULL };
 	vec_for_each(v, f) {
 		for (int i = 0; OTHER_LIST[i]; ++i) {
-			if (strcmp(f->filename, OTHER_LIST[i]) == 0)
+			if (strcmp(f->filename, OTHER_LIST[i]) == 0) {
 				ret |= OTHER_PATCH;
+				// Already find other files, abort
+				exit(OTHER_PATCH);
+			}
+		}
+		for (int i = 0; MAGISK_LIST[i]; ++i) {
+			if (strcmp(f->filename, MAGISK_LIST[i]) == 0)
+				ret = MAGISK_PATCH;
 		}
-		if (strcmp(f->filename, "init.magisk.rc") == 0)
-			ret |= MAGISK_PATCH;
 	}
 	cpio_vec_destroy(v);
-	exit((ret & OTHER_PATCH) ? OTHER_PATCH : (ret & MAGISK_PATCH));
+	exit(ret);
 }
 
-static int check_verity_pattern(const char *s) {
+int check_verity_pattern(const char *s) {
 	int pos = 0;
 	if (s[0] == ',') ++pos;
-	if (strncmp(s + pos, "verify", 6) != 0) return -1;
-	pos += 6;
+	if (strncmp(s + pos, "verify", 6) == 0)
+		pos += 6;
+	else if (strncmp(s + pos, "avb", 3) == 0)
+		pos += 3;
+	else
+		return -1;
+
 	if (s[pos] == '=') {
-		while (s[pos] != ' ' && s[pos] != '\n' && s[pos] != ',') ++pos;
+		while (s[pos] != '\0' && s[pos] != ' ' && s[pos] != '\n' && s[pos] != ',') ++pos;
 	}
 	return pos;
 }
 
-static void cpio_dmverity(struct vector *v) {
-	cpio_file *f;
-	size_t read, write;
-	int skip;
-	vec_for_each(v, f) {
-		if (strstr(f->filename, "fstab") != NULL && S_ISREG(f->mode)) {
-			for (read = 0, write = 0; read < f->filesize; ++read, ++write) {
-				skip = check_verity_pattern(f->data + read);
-				if (skip > 0) {
-					printf("Remove pattern [%.*s] in [%s]\n", (int) skip, f->data + read, f->filename);
-					read += skip;
-				}
-				f->data[write] = f->data[read];
-			}
-			f->filesize = write;
-		} else if (strcmp(f->filename, "verity_key") == 0) {
-			f->remove = 1;
-			break;
-		}
+int check_encryption_pattern(const char *s) {
+	const char *encrypt_list[] = { "forceencrypt", "forcefdeorfbe", NULL };
+	for (int i = 0 ; encrypt_list[i]; ++i) {
+		int len = strlen(encrypt_list[i]);
+		if (strncmp(s, encrypt_list[i], len) == 0)
+			return len;
 	}
+	return -1;
 }
 
-static void cpio_forceencrypt(struct vector *v) {
-	cpio_file *f;
-	size_t read, write;
-	const char *ENCRYPT_LIST[] = { "forceencrypt", "forcefdeorfbe", "fileencryptioninline", NULL };
+static void cpio_patch(struct vector *v, int keepverity, int keepforceencrypt) {
+	cpio_entry *f;
+	int skip, write;
 	vec_for_each(v, f) {
-		if (strstr(f->filename, "fstab") != NULL && S_ISREG(f->mode)) {
-			for (read = 0, write = 0; read < f->filesize; ++read, ++write) {
-				for (int i = 0 ; ENCRYPT_LIST[i]; ++i) {
-					if (strncmp(f->data + read, ENCRYPT_LIST[i], strlen(ENCRYPT_LIST[i])) == 0) {
-						memcpy(f->data + write, "encryptable", 11);
-						printf("Replace [%s] with [%s] in [%s]\n", ENCRYPT_LIST[i], "encryptable", f->filename);
-						write += 11;
-						read += strlen(ENCRYPT_LIST[i]);
-						break;
+		if (!keepverity) {
+			if (strstr(f->filename, "fstab") != NULL && S_ISREG(f->mode)) {
+				write = 0;
+				for (int read = 0; read < f->filesize; ++write, ++read) {
+					if ((skip = check_verity_pattern(f->data + read)) > 0) {
+						fprintf(stderr, "Remove pattern [%.*s] in [%s]\n", skip, f->data + read, f->filename);
+						read += skip;
 					}
+					f->data[write] = f->data[read];
 				}
-				f->data[write] = f->data[read];
+				f->filesize = write;
+			} else if (strcmp(f->filename, "verity_key") == 0) {
+				fprintf(stderr, "Remove [verity_key]\n");
+				f->remove = 1;
+			}
+		}
+		if (!keepforceencrypt) {
+			if (strstr(f->filename, "fstab") != NULL && S_ISREG(f->mode)) {
+				write = 0;
+				for (int read = 0; read < f->filesize; ++write, ++read) {
+					if ((skip = check_encryption_pattern(f->data + read)) > 0) {
+						// assert(skip > 11)!
+						fprintf(stderr, "Replace pattern [%.*s] with [encryptable] in [%s]\n", skip, f->data + read, f->filename);
+						memcpy(f->data + write, "encryptable", 11);
+						write += 11;
+						read += skip;
+					}
+					f->data[write] = f->data[read];
+				}
+				f->filesize = write;
 			}
-			f->filesize = write;
 		}
 	}
 }
 
 static void cpio_extract(const char *entry, const char *filename, struct vector *v) {
-	cpio_file *f;
+	cpio_entry *f;
 	vec_for_each(v, f) {
 		if (strcmp(f->filename, entry) == 0 && S_ISREG(f->mode)) {
-			printf("Extracting [%s] to [%s]\n\n", entry, filename);
-			int fd = open_new(filename);
+			fprintf(stderr, "Extracting [%s] to [%s]\n\n", entry, filename);
+			int fd = creat(filename, 0644);
 			xwrite(fd, f->data, f->filesize);
 			fchmod(fd, f->mode);
 			fchown(fd, f->uid, f->gid);
@@ -278,34 +283,55 @@ static void cpio_extract(const char *entry, const char *filename, struct vector
 			exit(0);
 		}
 	}
-	LOGE(1, "Cannot find the file entry [%s]\n", entry);
+	LOGE("Cannot find the file entry [%s]\n", entry);
 }
 
-static void cpio_backup(const char *orig, struct vector *v) {
+static void cpio_backup(const char *orig, const char *sha1, struct vector *v) {
 	struct vector o_body, *o = &o_body, bak;
-	cpio_file *m, *n, *dir, *rem;
+	cpio_entry *m, *n, *rem, *cksm;
 	char buf[PATH_MAX];
 	int res, doBak;
 
-	dir = xcalloc(sizeof(*dir), 1);
-	rem = xcalloc(sizeof(*rem), 1);
+	if (sha1) cksm = xcalloc(sizeof(*cksm), 1);
 	vec_init(o);
 	vec_init(&bak);
-	// First push back the directory and the rmlist
-	vec_push_back(&bak, dir);
+
+	m = xcalloc(sizeof(*m), 1);
+	m->filename = strdup(".backup");
+	m->namesize = strlen(m->filename) + 1;
+	m->mode = S_IFDIR;
+	vec_push_back(&bak, m);
+
+	m = xcalloc(sizeof(*m), 1);
+	m->filename = strdup(".backup/.magisk");
+	m->namesize = strlen(m->filename) + 1;
+	m->mode = S_IFREG;
+	vec_push_back(&bak, m);
+
+	rem = xcalloc(sizeof(*rem), 1);
+	rem->filename = strdup(".backup/.rmlist");
+	rem->namesize = strlen(rem->filename) + 1;
+	rem->mode = S_IFREG;
 	vec_push_back(&bak, rem);
+
+	if (sha1) vec_push_back(&bak, cksm);
 	parse_cpio(orig, o);
 	// Remove possible backups in original ramdisk
 	cpio_rm(1, ".backup", o);
 	cpio_rm(1, ".backup", v);
 
-	// Init the directory and rmlist
-	dir->filename = strdup(".backup");
-	dir->namesize = strlen(dir->filename) + 1;
-	dir->mode = S_IFDIR;
-	rem->filename = strdup(".backup/.rmlist");
-	rem->namesize = strlen(rem->filename) + 1;
-	rem->mode = S_IFREG;
+	// Sort both vectors before comparing
+	vec_sort(v, cpio_cmp);
+	vec_sort(o, cpio_cmp);
+
+	if (sha1) {
+		fprintf(stderr, "Save SHA1: [%s] -> [.backup/.sha1]\n", sha1);
+		cksm->filename = strdup(".backup/.sha1");
+		cksm->namesize = strlen(cksm->filename) + 1;
+		cksm->mode = S_IFREG;
+		cksm->data = strdup(sha1);
+		cksm->filesize = strlen(sha1) + 1;
+	}
 
 	// Start comparing
 	size_t i = 0, j = 0;
@@ -327,14 +353,14 @@ static void cpio_backup(const char *orig, struct vector *v) {
 			// Something is missing in new ramdisk, backup!
 			++i;
 			doBak = 1;
-			printf("Backup missing entry: ");
+			fprintf(stderr, "Backup missing entry: ");
 		} else if (res == 0) {
 			++i; ++j;
 			if (m->filesize == n->filesize && memcmp(m->data, n->data, m->filesize) == 0)
 				continue;
 			// Not the same!
 			doBak = 1;
-			printf("Backup mismatch entry: ");
+			fprintf(stderr, "Backup mismatch entry: ");
 		} else {
 			// Someting new in ramdisk, record in rem
 			++j;
@@ -342,14 +368,14 @@ static void cpio_backup(const char *orig, struct vector *v) {
 			rem->data = xrealloc(rem->data, rem->filesize + n->namesize);
 			memcpy(rem->data + rem->filesize, n->filename, n->namesize);
 			rem->filesize += n->namesize;
-			printf("Record new entry: [%s] -> [.backup/.rmlist]\n", n->filename);
+			fprintf(stderr, "Record new entry: [%s] -> [.backup/.rmlist]\n", n->filename);
 		}
 		if (doBak) {
 			m->namesize += 8;
 			m->filename = realloc(m->filename, m->namesize);
 			strcpy(buf, m->filename);
 			sprintf(m->filename, ".backup/%s", buf);
-			printf("[%s] -> [%s]\n", buf, m->filename);
+			fprintf(stderr, "[%s] -> [%s]\n", buf, m->filename);
 			vec_push_back(&bak, m);
 			// NULL the original entry, so it won't be freed
 			vec_entry(o)[i - 1] = NULL;
@@ -361,43 +387,38 @@ static void cpio_backup(const char *orig, struct vector *v) {
 		vec_push_back(v, m);
 	}
 
-	// Don't include if empty
-	if (rem->filesize == 0) {
+	if (rem->filesize == 0)
 		rem->remove = 1;
-		if (bak.size == 2)
-			dir->remove = 1;
-	}
-
-	// Sort
-	vec_sort(v, cpio_compare);
 
 	// Cleanup
 	cpio_vec_destroy(o);
 }
 
 static int cpio_restore(struct vector *v) {
-	cpio_file *f, *n;
+	cpio_entry *f, *n;
 	int ret = 1;
 	vec_for_each(v, f) {
 		if (strstr(f->filename, ".backup") != NULL) {
 			ret = 0;
 			f->remove = 1;
-			if (strcmp(f->filename, ".backup") == 0) continue;
-			if (strcmp(f->filename, ".backup/.rmlist") == 0) {
-				for (int pos = 0; pos < f->filesize; pos += strlen(f->data + pos) + 1)
-					cpio_rm(0, f->data + pos, v);
+			if (f->filename[7] == '\0') continue;
+			if (f->filename[8] == '.') {
+				if (strcmp(f->filename, ".backup/.rmlist") == 0) {
+					for (int pos = 0; pos < f->filesize; pos += strlen(f->data + pos) + 1)
+						cpio_rm(0, f->data + pos, v);
+				}
 				continue;
+			} else {
+				n = xcalloc(sizeof(*n), 1);
+				memcpy(n, f, sizeof(*f));
+				n->namesize -= 8;
+				n->filename = strdup(f->filename + 8);
+				n->data = f->data;
+				f->data = NULL;
+				n->remove = 0;
+				fprintf(stderr, "Restore [%s] -> [%s]\n", f->filename, n->filename);
+				cpio_vec_insert(v, n);
 			}
-			n = xcalloc(sizeof(*n), 1);
-			memcpy(n, f, sizeof(*f));
-			n->namesize -= 8;
-			n->filename = xmalloc(n->namesize);
-			memcpy(n->filename, f->filename + 8, n->namesize);
-			n->data = xmalloc(n->filesize);
-			memcpy(n->data, f->data, n->filesize);
-			n->remove = 0;
-			printf("Restoring [%s] -> [%s]\n", f->filename, n->filename);
-			cpio_vec_insert(v, n);
 		}
 	}
 	// Some known stuff we can remove
@@ -407,6 +428,48 @@ static int cpio_restore(struct vector *v) {
 	return ret;
 }
 
+static void cpio_stocksha1(struct vector *v) {
+	cpio_entry *f;
+	char sha1[41];
+	vec_for_each(v, f) {
+		if (strcmp(f->filename, "init.magisk.rc") == 0
+			|| strcmp(f->filename, "overlay/init.magisk.rc") == 0) {
+			for (char *pos = f->data; pos < f->data + f->filesize; pos = strchr(pos + 1, '\n') + 1) {
+				if (memcmp(pos, "# STOCKSHA1=", 12) == 0) {
+					pos += 12;
+					memcpy(sha1, pos, 40);
+					sha1[40] = '\0';
+					printf("%s\n", sha1);
+					return;
+				}
+			}
+		} else if (strcmp(f->filename, ".backup/.sha1") == 0) {
+			printf("%s\n", f->data);
+		}
+	}
+}
+
+static void cpio_mv(struct vector *v, const char *from, const char *to) {
+	struct cpio_entry *f, *t;
+	vec_for_each(v, f) {
+		if (strcmp(f->filename, from) == 0) {
+			fprintf(stderr, "Move [%s] -> [%s]\n", from, to);
+			vec_for_each(v, t) {
+				if (strcmp(t->filename, to) == 0) {
+					t->remove = 1;
+					break;
+				}
+			}
+			free(f->filename);
+			f->namesize = strlen(to) + 1;
+			f->filename = strdup(to);
+			return;
+		}
+	}
+	fprintf(stderr, "Cannot find entry %s\n", from);
+	exit(1);
+}
+
 int cpio_commands(const char *command, int argc, char *argv[]) {
 	int recursive = 0, ret = 0;
 	command_t cmd;
@@ -415,13 +478,11 @@ int cpio_commands(const char *command, int argc, char *argv[]) {
 	--argc;
 	if (strcmp(command, "test") == 0) {
 		cmd = TEST;
-	} else if (strcmp(command, "patch-dmverity") == 0) {
-		cmd = DMVERITY;
-	} else if (strcmp(command, "patch-forceencrypt") == 0) {
-		cmd = FORCEENCRYPT;
 	} else if (strcmp(command, "restore") == 0) {
 		cmd = RESTORE;
-	} else if (argc == 1 && strcmp(command, "backup") == 0) {
+	} else if (strcmp(command, "stocksha1") == 0) {
+		cmd = STOCKSHA1;
+	} else if (argc >= 1 && strcmp(command, "backup") == 0) {
 		cmd = BACKUP;
 	} else if (argc > 0 && strcmp(command, "rm") == 0) {
 		cmd = RM;
@@ -430,6 +491,10 @@ int cpio_commands(const char *command, int argc, char *argv[]) {
 			++argv;
 			--argc;
 		}
+	} else if (argc == 2 && strcmp(command, "mv") == 0) {
+		cmd = MV;
+	} else if (argc == 2 && strcmp(command, "patch") == 0) {
+		cmd = PATCH;
 	} else if (argc == 2 && strcmp(command, "extract") == 0) {
 		cmd = EXTRACT;
 	} else if (argc == 2 && strcmp(command, "mkdir") == 0) {
@@ -438,41 +503,42 @@ int cpio_commands(const char *command, int argc, char *argv[]) {
 		cmd = ADD;
 	} else {
 		cmd = NONE;
-		return 1;
 	}
 	struct vector v;
 	vec_init(&v);
 	parse_cpio(incpio, &v);
 	switch(cmd) {
-		case TEST:
-			cpio_test(&v);
-			break;
-		case DMVERITY:
-			cpio_dmverity(&v);
-			break;
-		case FORCEENCRYPT:
-			cpio_forceencrypt(&v);
-			break;
-		case RESTORE:
-			ret = cpio_restore(&v);
-			break;
-		case BACKUP:
-			cpio_backup(argv[0], &v);
-		case RM:
-			cpio_rm(recursive, argv[0], &v);
-			break;
-		case EXTRACT:
-			cpio_extract(argv[0], argv[1], &v);
-			break;
-		case MKDIR:
-			cpio_mkdir(strtoul(argv[0], NULL, 8), argv[1], &v);
-			break;
-		case ADD:
-			cpio_add(strtoul(argv[0], NULL, 8), argv[1], argv[2], &v);
-			break;
-		default:
-			// Never happen
-			break;
+	case TEST:
+		cpio_test(&v);
+		break;
+	case RESTORE:
+		ret = cpio_restore(&v);
+		break;
+	case STOCKSHA1:
+		cpio_stocksha1(&v);
+		return 0;
+	case BACKUP:
+		cpio_backup(argv[0], argc > 1 ? argv[1] : NULL, &v);
+	case RM:
+		cpio_rm(recursive, argv[0], &v);
+		break;
+	case PATCH:
+		cpio_patch(&v, strcmp(argv[0], "true") == 0, strcmp(argv[1], "true") == 0);
+		break;
+	case EXTRACT:
+		cpio_extract(argv[0], argv[1], &v);
+		break;
+	case MKDIR:
+		cpio_mkdir(strtoul(argv[0], NULL, 8), argv[1], &v);
+		break;
+	case ADD:
+		cpio_add(strtoul(argv[0], NULL, 8), argv[1], argv[2], &v);
+		break;
+	case MV:
+		cpio_mv(&v, argv[0], argv[1]);
+		break;
+	case NONE:
+		return 1;
 	}
 	dump_cpio(incpio, &v);
 	cpio_vec_destroy(&v);

jni/magiskboot/cpio.h

@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-typedef struct cpio_file {
+typedef struct cpio_entry {
 	// uint32_t ino;
 	uint32_t mode;
 	uint32_t uid;
@@ -20,7 +20,7 @@ typedef struct cpio_file {
 	char *filename;
 	char *data;
 	int remove;
-} cpio_file;
+} cpio_entry;
 
 typedef struct cpio_newc_header {
 	char magic[6];
@@ -39,4 +39,18 @@ typedef struct cpio_newc_header {
 	char check[8];
 } cpio_newc_header;
 
+typedef enum {
+    NONE,
+    RM,
+    MKDIR,
+    ADD,
+    MV,
+    EXTRACT,
+    TEST,
+    PATCH,
+    BACKUP,
+    RESTORE,
+    STOCKSHA1
+} command_t;
+
 #endif

jni/magiskboot/dtb.c

@@ -0,0 +1,117 @@
+#include <libfdt.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#include "magiskboot.h"
+#include "utils.h"
+
+extern int check_verity_pattern(const char *s);
+
+static void print_props(const void *fdt, int node, int depth) {
+	int prop;
+	fdt_for_each_property_offset(prop, fdt, node) {
+		for (int i = 0; i < depth; ++i) printf("    ");
+		printf("  ");
+		int size;
+		const char *name;
+		const char *value = fdt_getprop_by_offset(fdt, prop, &name, &size);
+		printf("[%s]: [%s]\n", name, value);
+	}
+}
+
+static void print_subnode(const void *fdt, int parent, int depth) {
+	int node;
+	fdt_for_each_subnode(node, fdt, parent) {
+		for (int i = 0; i < depth; ++i) printf("    ");
+		printf("#%d: %s\n", node, fdt_get_name(fdt, node, NULL));
+		print_props(fdt, node, depth);
+		print_subnode(fdt, node, depth + 1);
+	}
+}
+
+static int find_fstab(const void *fdt, int parent) {
+	int node, fstab;
+	fdt_for_each_subnode(node, fdt, parent) {
+		if (strcmp(fdt_get_name(fdt, node, NULL), "fstab") == 0)
+			return node;
+		fstab = find_fstab(fdt, node);
+		if (fstab != -1)
+			return fstab;
+	}
+	return -1;
+}
+
+static void dtb_dump(const char *file) {
+	size_t size ;
+	void *dtb, *fdt;
+	fprintf(stderr, "Loading dtbs from [%s]\n", file);
+	mmap_ro(file, &dtb, &size);
+	// Loop through all the dtbs
+	int dtb_num = 0;
+	for (int i = 0; i < size; ++i) {
+		if (memcmp(dtb + i, DTB_MAGIC, 4) == 0) {
+			fdt = dtb + i;
+			fprintf(stderr, "Dumping dtb.%04d\n\n", dtb_num++);
+			print_subnode(fdt, 0, 0);
+		}
+	}
+	fprintf(stderr, "\n");
+	munmap(dtb, size);
+	exit(0);
+}
+
+static void dtb_patch(const char *file, int patch) {
+	size_t size ;
+	void *dtb, *fdt;
+	fprintf(stderr, "Loading dtbs from [%s]\n\n", file);
+	if (patch)
+		mmap_rw(file, &dtb, &size);
+	else
+		mmap_ro(file, &dtb, &size);
+	// Loop through all the dtbs
+	int dtb_num = 0, found = 0;
+	for (int i = 0; i < size; ++i) {
+		if (memcmp(dtb + i, DTB_MAGIC, 4) == 0) {
+			fdt = dtb + i;
+			int fstab = find_fstab(fdt, 0);
+			if (fstab > 0) {
+				fprintf(stderr, "Found fstab in dtb.%04d\n", dtb_num++);
+				int block;
+				fdt_for_each_subnode(block, fdt, fstab) {
+					fprintf(stderr, "Found block [%s] in fstab\n", fdt_get_name(fdt, block, NULL));
+					int skip, value_size;
+					char *value = (char *) fdt_getprop(fdt, block, "fsmgr_flags", &value_size);
+					for (int i = 0; i < value_size; ++i) {
+						if ((skip = check_verity_pattern(value + i)) > 0) {
+							if (patch) {
+								fprintf(stderr, "Remove pattern [%.*s] in [fsmgr_flags]\n", skip, value + i);
+								memcpy(value + i, value + i + skip, value_size - i - skip);
+								memset(value + value_size - skip, '\0', skip);
+							} else {
+								fprintf(stderr, "Found pattern [%.*s] in [fsmgr_flags]\n", skip, value + i);
+								i += skip - 1;
+							}
+							found = 1;
+						}
+					}
+				}
+			}
+		}
+	}
+	fprintf(stderr, "\n");
+	munmap(dtb, size);
+	exit(!found);
+}
+
+int dtb_commands(const char *cmd, int argc, char *argv[]) {
+	if (argc == 0) return 1;
+	if (strcmp(cmd, "dump") == 0)
+		dtb_dump(argv[0]);
+	else if (strcmp(cmd, "patch") == 0)
+		dtb_patch(argv[0], 1);
+	else if (strcmp(cmd, "test") == 0)
+		dtb_patch(argv[0], 0);
+	return 0;
+}
+
+

jni/magiskboot/hexpatch.c

@@ -1,4 +1,10 @@
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <sys/mman.h>
+
 #include "magiskboot.h"
+#include "utils.h"
 
 static void hex2byte(const char *hex, unsigned char *str) {
 	char high, low;
@@ -12,15 +18,15 @@ static void hex2byte(const char *hex, unsigned char *str) {
 void hexpatch(const char *image, const char *from, const char *to) {
 	int patternsize = strlen(from) / 2, patchsize = strlen(to) / 2;
 	size_t filesize;
-	unsigned char *file, *pattern, *patch;
+	void *file, *pattern, *patch;
 	mmap_rw(image, &file, &filesize);
 	pattern = xmalloc(patternsize);
 	patch = xmalloc(patchsize);
 	hex2byte(from, pattern);
 	hex2byte(to, patch);
-	for (size_t i = 0; i < filesize - patternsize; ++i) {
+	for (size_t i = 0; filesize > 0 && i < filesize - patternsize; ++i) {
 		if (memcmp(file + i, pattern, patternsize) == 0) {
-			printf("Pattern %s found!\nPatching to %s\n", from, to);
+			fprintf(stderr, "Pattern %s found!\nPatching to %s\n", from, to);
 			memset(file + i, 0, patternsize);
 			memcpy(file + i, patch, patchsize);
 			i += patternsize - 1;

jni/magiskboot/magisk.h

@@ -1,10 +0,0 @@
-/* magisk.h - Let MagiskBoot use the same error handling API as main magisk program
- */
-
-#ifndef _MAGISK_H_
-#define _MAGISK_H_
-
-#define LOGE(err, ...) { fprintf(stderr, __VA_ARGS__); exit(err); }
-#define PLOGE(fmt, args...) { fprintf(stderr, fmt " failed with %d: %s\n\n", ##args, errno, strerror(errno)); exit(1); }
-
-#endif

jni/magiskboot/magiskboot.h

@@ -1,101 +1,35 @@
 #ifndef _MAGISKBOOT_H_
 #define _MAGISKBOOT_H_
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <unistd.h>
-#include <ctype.h>
 #include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <string.h>
 
+#include "logging.h"
 #include "bootimg.h"
-#include "sha1.h"
-#include "magisk.h"
-#include "utils.h"
-
-#define CHROMEOS_MAGIC  "CHROMEOS"
-#define ELF32_MAGIC     "\x7f""ELF\x01"
-#define ELF64_MAGIC     "\x7f""ELF\x02"
 
 #define KERNEL_FILE     "kernel"
 #define RAMDISK_FILE    "ramdisk.cpio"
 #define SECOND_FILE     "second"
+#define EXTRA_FILE      "extra"
 #define DTB_FILE        "dtb"
 #define NEW_BOOT        "new-boot.img"
 
-#define str(a) #a
-#define xstr(a) str(a)
-
-typedef enum {
-    UNKNOWN,
-    CHROMEOS,
-    AOSP,
-    ELF32,
-    ELF64,
-    GZIP,
-    LZOP,
-    XZ,
-    LZMA,
-    BZIP2,
-    LZ4,
-    LZ4_LEGACY,
-    MTK
-} file_t;
-
-typedef enum {
-    NONE,
-    RM,
-    MKDIR,
-    ADD,
-    EXTRACT,
-    TEST,
-    DMVERITY,
-    FORCEENCRYPT,
-    BACKUP,
-    RESTORE
-} command_t;
-
-extern char *SUP_LIST[];
-extern char *SUP_EXT_LIST[];
-extern file_t SUP_TYPE_LIST[];
-
-// Global variables
-extern unsigned char *kernel, *ramdisk, *second, *dtb, *extra;
-extern boot_img_hdr hdr;
-extern file_t ramdisk_type;
-extern int mtk_kernel, mtk_ramdisk;
-
 // Main entries
 void unpack(const char *image);
 void repack(const char* orig_image, const char* out_image);
 void hexpatch(const char *image, const char *from, const char *to);
-void parse_img(unsigned char *orig, size_t size);
-int cpio_commands(const char *command, int argc, char *argv[]);
-void cleanup();
+int parse_img(void *orig, size_t size, boot_img *boot);
+int cpio_commands(const char *cmd, int argc, char *argv[]);
+void comp_file(const char *method, const char *from, const char *to);
+void decomp_file(char *from, const char *to);
+int dtb_commands(const char *cmd, int argc, char *argv[]);
 
 // Compressions
-void gzip(int mode, const char* filename, const unsigned char* buf, size_t size);
-void lzma(int mode, const char* filename, const unsigned char* buf, size_t size);
-void lz4(int mode, const char* filename, const unsigned char* buf, size_t size);
-void bzip2(int mode, const char* filename, const unsigned char* buf, size_t size);
-void lz4_legacy(int mode, const char* filename, const unsigned char* buf, size_t size);
-int comp(file_t type, const char *to, const unsigned char *from, size_t size);
-void comp_file(const char *method, const char *from, const char *to);
-int decomp(file_t type, const char *to, const unsigned char *from, size_t size);
-void decomp_file(char *from, const char *to);
-
-// Utils
-void mmap_ro(const char *filename, unsigned char **buf, size_t *size);
-void mmap_rw(const char *filename, unsigned char **buf, size_t *size);
-file_t check_type(const unsigned char *buf);
-void write_zero(int fd, size_t size);
-void mem_align(size_t *pos, size_t align);
-void file_align(int fd, size_t align, int out);
-int open_new(const char *filename);
-void print_info();
+size_t gzip(int mode, int fd, const void *buf, size_t size);
+size_t lzma(int mode, int fd, const void *buf, size_t size);
+size_t lz4(int mode, int fd, const void *buf, size_t size);
+size_t bzip2(int mode, int fd, const void *buf, size_t size);
+size_t lz4_legacy(int mode, int fd, const void *buf, size_t size);
+long long comp(file_t type, int to, const void *from, size_t size);
+long long decomp(file_t type, int to, const void *from, size_t size);
 
 #endif

jni/magiskboot/main.c

@@ -1,4 +1,12 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
 #include "magiskboot.h"
+#include "utils.h"
+#include "sha1.h"
 
 /********************
   Patch Boot Image
@@ -6,67 +14,105 @@
 
 static void usage(char *arg0) {
 	fprintf(stderr,
-		"%s --unpack <bootimg>\n"
-		"  Unpack <bootimg> to kernel, ramdisk.cpio, (second), (dtb) into the\n  current directory\n"
+		"Usage: %s <action> [args...]\n"
 		"\n"
-		"%s --repack <origbootimg> [outbootimg]\n"
+		"Supported actions:\n"
+		" --unpack <bootimg>\n"
+		"  Unpack <bootimg> to kernel, ramdisk.cpio, (second), (dtb), (extra) into\n"
+		"  the current directory\n"
+		"\n"
+		" --repack <origbootimg> [outbootimg]\n"
 		"  Repack kernel, ramdisk.cpio[.ext], second, dtb... from current directory\n"
 		"  to [outbootimg], or new-boot.img if not specified.\n"
 		"  It will compress ramdisk.cpio with the same method used in <origbootimg>\n"
 		"  if exists, or attempt to find ramdisk.cpio.[ext], and repack\n"
 		"  directly with the compressed ramdisk file\n"
 		"\n"
-		"%s --hexpatch <file> <hexpattern1> <hexpattern2>\n"
+		" --hexpatch <file> <hexpattern1> <hexpattern2>\n"
 		"  Search <hexpattern1> in <file>, and replace with <hexpattern2>\n"
 		"\n"
-		"%s --cpio-<cmd> <incpio> [flags...] [params...]\n"
-		"  Do cpio related cmds to <incpio> (modifications are done directly)\n  Supported commands:\n"
-		"  --cpio-rm <incpio> [-r] <entry>\n    Remove entry from cpio, flag -r to remove recursively\n"
-		"  --cpio-mkdir <incpio> <mode> <entry>\n    Create directory as an <entry>\n"
-		"  --cpio-add <incpio> <mode> <entry> <infile>\n    Add <infile> as an <entry>; replaces <entry> if already exists\n"
-		"  --cpio-extract <incpio> <entry> <outfile>\n    Extract <entry> to <outfile>\n"
-		"  --cpio-test <incpio>\n    Return value: 0/not patched 1/Magisk 2/SuperSU\n"
-		"  --cpio-patch-dmverity <incpio>\n    Remove dm-verity\n"
-		"  --cpio-patch-forceencrypt <incpio>\n    Change forceencrypt flag to encryptable\n"
-		"  --cpio-backup <incpio> <origcpio>\n    Create ramdisk backups into <incpio> from <origcpio>\n"
-		"  --cpio-restore <incpio>\n    Restore ramdisk from ramdisk backup within <incpio>\n"
+		" --cpio-<cmd> <incpio> [flags...] [args...]\n"
+		"  Do cpio related cmds to <incpio> (modifications are done directly)\n"
+		"  Supported commands:\n"
+		"    -rm [-r] <entry>\n"
+		"      Remove entry from <incpio>, flag -r to remove recursively\n"
+		"    -mkdir <mode> <entry>\n"
+		"      Create directory as an <entry>\n"
+		"    -add <mode> <entry> <infile>\n"
+		"      Add <infile> as an <entry>; replaces <entry> if already exists\n"
+		"    -mv <from-entry> <to-entry>\n"
+		"      Move <from-entry> to <to-entry>\n"
+		"    -extract <entry> <outfile>\n"
+		"      Extract <entry> to <outfile>\n"
+		"    -test\n"
+		"      Return value: 0/stock 1/Magisk 2/other (phh, SuperSU, Xposed)\n"
+		"    -patch <KEEPVERITY> <KEEPFORCEENCRYPT>\n"
+		"      Patch cpio for Magisk. KEEP**** are true/false values\n"
+		"    -backup <origcpio> [SHA1]\n"
+		"      Create ramdisk backups into <incpio> from <origcpio>\n"
+		"      SHA1 of stock boot image is optional\n"
+		"    -restore\n"
+		"      Restore ramdisk from ramdisk backup within <incpio>\n"
+		"    -stocksha1\n"
+		"      Get stock boot SHA1 recorded within <incpio>\n"
 		"\n"
-		"%s --compress[=method] <infile> [outfile]\n"
-		"  Compress <infile> with [method] (default: gzip), optionally to [outfile]\n  Supported methods: "
-	, arg0, arg0, arg0, arg0, arg0);
-	for (int i = 0; SUP_LIST[i]; ++i)
-		fprintf(stderr, "%s ", SUP_LIST[i]);
-	fprintf(stderr,
+		" --dtb-<cmd> <dtb>\n"
+		"  Do dtb related cmds to <dtb> (modifications are done directly)\n"
+		"  Supported commands:\n"
+		"    -dump\n"
+		"      Dump all contents from dtb for debugging\n"
+		"    -patch\n"
+		"      Search for fstab and remove verity/avb\n"
 		"\n"
-		"\n"
-		"%s --decompress <infile> [outfile]\n"
-		"  Detect method and decompress <infile>, optionally to [outfile]\n  Supported methods: "
+		" --compress[=method] <infile> [outfile]\n"
+		"  Compress <infile> with [method] (default: gzip), optionally to [outfile]\n"
+		"  <infile>/[outfile] can be '-' to be STDIN/STDOUT\n"
+		"  Supported methods: "
 	, arg0);
 	for (int i = 0; SUP_LIST[i]; ++i)
 		fprintf(stderr, "%s ", SUP_LIST[i]);
 	fprintf(stderr,
 		"\n"
 		"\n"
-		"%s --sha1 <file>\n"
+		" --decompress <infile> [outfile]\n"
+		"  Detect method and decompress <infile>, optionally to [outfile]\n"
+		"  <infile>/[outfile] can be '-' to be STDIN/STDOUT\n"
+		"  Supported methods: ");
+	for (int i = 0; SUP_LIST[i]; ++i)
+		fprintf(stderr, "%s ", SUP_LIST[i]);
+	fprintf(stderr,
+		"\n"
+		"\n"
+		" --sha1 <file>\n"
 		"  Print the SHA1 checksum for <file>\n"
 		"\n"
-		"%s --cleanup\n"
+		" --cleanup\n"
 		"  Cleanup the current working directory\n"
-		"\n"
-	, arg0, arg0);
+		"\n");
 
 	exit(1);
 }
 
 int main(int argc, char *argv[]) {
-	printf("MagiskBoot v" xstr(MAGISK_VERSION) " (by topjohnwu) - Boot Image Modification Tool\n\n");
+	fprintf(stderr, "MagiskBoot v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") (by topjohnwu) - Boot Image Modification Tool\n\n");
 
 	if (argc > 1 && strcmp(argv[1], "--cleanup") == 0) {
-		cleanup();
+		fprintf(stderr, "Cleaning up...\n\n");
+		char name[PATH_MAX];
+		unlink(KERNEL_FILE);
+		unlink(RAMDISK_FILE);
+		unlink(RAMDISK_FILE ".raw");
+		unlink(SECOND_FILE);
+		unlink(DTB_FILE);
+		unlink(EXTRA_FILE);
+		for (int i = 0; SUP_EXT_LIST[i]; ++i) {
+			sprintf(name, "%s.%s", RAMDISK_FILE, SUP_EXT_LIST[i]);
+			unlink(name);
+		}
 	} else if (argc > 2 && strcmp(argv[1], "--sha1") == 0) {
 		char sha1[21], *buf;
 		size_t size;
-		mmap_ro(argv[2], (unsigned char **) &buf, &size);
+		mmap_ro(argv[2], (void **) &buf, &size);
 		SHA1(sha1, buf, size);
 		for (int i = 0; i < 20; ++i)
 			printf("%02x", sha1[i]);
@@ -87,11 +133,15 @@ int main(int argc, char *argv[]) {
 	} else if (argc > 4 && strcmp(argv[1], "--hexpatch") == 0) {
 		hexpatch(argv[2], argv[3], argv[4]);
 	} else if (argc > 2 && strncmp(argv[1], "--cpio", 6) == 0) {
-		char *command;
-		command = strchr(argv[1] + 2, '-');
-		if (command == NULL) usage(argv[0]);
-		else ++command;
-		if (cpio_commands(command, argc - 2, argv + 2)) usage(argv[0]);
+		char *cmd = argv[1] + 6;
+		if (*cmd == '\0') usage(argv[0]);
+		else ++cmd;
+		if (cpio_commands(cmd, argc - 2, argv + 2)) usage(argv[0]);
+	} else if (argc > 2 && strncmp(argv[1], "--dtb", 5) == 0) {
+		char *cmd = argv[1] + 5;
+		if (*cmd == '\0') usage(argv[0]);
+		else ++cmd;
+		if (dtb_commands(cmd, argc - 2, argv + 2)) usage(argv[0]);
 	} else {
 		usage(argv[0]);
 	}

jni/magiskboot/parseimg.c

@@ -1,91 +0,0 @@
-#include "bootimg.h"
-#include "magiskboot.h"
-
-unsigned char *kernel, *ramdisk, *second, *dtb, *extra;
-boot_img_hdr hdr;
-int mtk_kernel = 0, mtk_ramdisk = 0;
-file_t ramdisk_type;
-
-static void check_headers() {
-	// Check ramdisk compression type
-	ramdisk_type = check_type(ramdisk);
-
-	// Check MTK
-	if (check_type(kernel) == MTK) {
-		printf("MTK header found in kernel\n");
-		mtk_kernel = 1;
-	}
-	if (ramdisk_type == MTK) {
-		printf("MTK header found in ramdisk\n");
-		mtk_ramdisk = 1;
-		ramdisk_type = check_type(ramdisk + 512);
-	}
-
-	// Print info
-	print_info();
-}
-
-static void parse_aosp(unsigned char *base, size_t size) {
-
-	// printf("IMG [AOSP]\n");
-
-	size_t pos = 0;
-
-	// Read the header
-	memcpy(&hdr, base, sizeof(hdr));
-	pos += hdr.page_size;
-
-	// Kernel position
-	kernel = base + pos;
-	pos += hdr.kernel_size;
-	mem_align(&pos, hdr.page_size);
-
-	// Ramdisk position
-	ramdisk = base + pos;
-	pos += hdr.ramdisk_size;
-	mem_align(&pos, hdr.page_size);
-
-	if (hdr.second_size) {
-		// Second position
-		second = base + pos;
-		pos += hdr.second_size;
-		mem_align(&pos, hdr.page_size);
-	}
-
-	if (hdr.dt_size) {
-		// dtb position
-		dtb = base + pos;
-		pos += hdr.dt_size;
-		mem_align(&pos, hdr.page_size);
-	}
-
-	if (pos < size) {
-		extra = base + pos;
-	}
-
-	check_headers();
-}
-
-void parse_img(unsigned char *orig, size_t size) {
-	unsigned char *base, *end;
-	for(base = orig, end = orig + size; base < end; base += 256, size -= 256) {
-		switch (check_type(base)) {
-		case CHROMEOS:
-			// The caller should know it's chromeos, as it needs additional signing
-			close(open_new("chromeos"));
-			continue;
-		case ELF32:
-			exit(2);
-			return;
-		case ELF64:
-			exit(3);
-			return;
-		case AOSP:
-			parse_aosp(base, size);
-			return;
-		default:
-			continue;
-		}
-	}
-	LOGE(1, "No boot image magic found!\n");
-}

jni/magiskboot/repack.c

@@ -1,136 +0,0 @@
-#include "magiskboot.h"
-
-static size_t restore(const char *filename, int fd) {
-	int ifd = xopen(filename, O_RDONLY);
-	size_t size = lseek(ifd, 0, SEEK_END);
-	lseek(ifd, 0, SEEK_SET);
-	xsendfile(fd, ifd, NULL, size);
-	close(ifd);
-	return size;
-}
-
-static void restore_buf(int fd, const void *buf, size_t size) {
-	xwrite(fd, buf, size);
-}
-
-void repack(const char* orig_image, const char* out_image) {
-	size_t size;
-	unsigned char *orig;
-	char name[PATH_MAX];
-
-	// There are possible two MTK headers
-	mtk_hdr mtk_kernel_hdr, mtk_ramdisk_hdr;
-	size_t mtk_kernel_off, mtk_ramdisk_off;
-
-	// Load original image
-	mmap_ro(orig_image, &orig, &size);
-
-	// Parse original image
-	printf("Parsing boot image: [%s]\n\n", orig_image);
-	parse_img(orig, size);
-
-	printf("Repack to boot image: [%s]\n\n", out_image);
-
-	// Create new image
-	int fd = open_new(out_image);
-
-	// Set all sizes to 0
-	hdr.kernel_size = 0;
-	hdr.ramdisk_size = 0;
-	hdr.second_size = 0;
-	hdr.dt_size = 0;
-
-	// Skip a page for header
-	write_zero(fd, hdr.page_size);
-
-	// Restore kernel
-	if (mtk_kernel) {
-		mtk_kernel_off = lseek(fd, 0, SEEK_CUR);
-		restore_buf(fd, kernel, 512);
-		memcpy(&mtk_kernel_hdr, kernel, sizeof(mtk_kernel_hdr));
-	}
-	hdr.kernel_size = restore(KERNEL_FILE, fd);
-	file_align(fd, hdr.page_size, 1);
-
-	// Restore ramdisk
-	if (mtk_ramdisk) {
-		mtk_ramdisk_off = lseek(fd, 0, SEEK_CUR);
-		restore_buf(fd, ramdisk, 512);
-		memcpy(&mtk_ramdisk_hdr, ramdisk, sizeof(mtk_ramdisk_hdr));
-	}
-	if (access(RAMDISK_FILE, R_OK) == 0) {
-		// If we found raw cpio, compress to original format
-
-		// Before we start, clean up previous compressed files
-		for (int i = 0; SUP_EXT_LIST[i]; ++i) {
-			sprintf(name, "%s.%s", RAMDISK_FILE, SUP_EXT_LIST[i]);
-			unlink(name);
-		}
-
-		size_t cpio_size;
-		unsigned char *cpio;
-		mmap_ro(RAMDISK_FILE, &cpio, &cpio_size);
-
-		if (comp(ramdisk_type, RAMDISK_FILE, cpio, cpio_size))
-			LOGE(1, "Unsupported ramdisk format!\n");
-
-		munmap(cpio, cpio_size);
-	}
-
-	int found = 0;
-	for (int i = 0; SUP_EXT_LIST[i]; ++i) {
-		sprintf(name, "%s.%s", RAMDISK_FILE, SUP_EXT_LIST[i]);
-		if (access(name, R_OK) == 0) {
-			ramdisk_type = SUP_TYPE_LIST[i];
-			found = 1;
-			break;
-		}
-	}
-	if (!found)
-		LOGE(1, "No ramdisk exists!\n");
-	hdr.ramdisk_size = restore(name, fd);
-	file_align(fd, hdr.page_size, 1);
-
-	// Restore second
-	if (access(SECOND_FILE, R_OK) == 0) {
-		hdr.second_size = restore(SECOND_FILE, fd);
-		file_align(fd, hdr.page_size, 1);
-	}
-
-	// Restore dtb
-	if (access(DTB_FILE, R_OK) == 0) {
-		hdr.dt_size = restore(DTB_FILE, fd);
-		file_align(fd, hdr.page_size, 1);
-	}
-
-	// Check extra info, currently only for LG Bump and Samsung SEANDROIDENFORCE
-	if (extra) {
-		if (memcmp(extra, "SEANDROIDENFORCE", 16) == 0 || 
-			memcmp(extra, "\x41\xa9\xe4\x67\x74\x4d\x1d\x1b\xa4\x29\xf2\xec\xea\x65\x52\x79", 16) == 0 ) {
-			restore_buf(fd, extra, 16);
-		}
-	}
-
-	// Write headers back
-	if (mtk_kernel) {
-		lseek(fd, mtk_kernel_off, SEEK_SET);
-		mtk_kernel_hdr.size = hdr.kernel_size;
-		hdr.kernel_size += 512;
-		restore_buf(fd, &mtk_kernel_hdr, sizeof(mtk_kernel_hdr));
-	}
-	if (mtk_ramdisk) {
-		lseek(fd, mtk_ramdisk_off, SEEK_SET);
-		mtk_ramdisk_hdr.size = hdr.ramdisk_size;
-		hdr.ramdisk_size += 512;
-		restore_buf(fd, &mtk_ramdisk_hdr, sizeof(mtk_ramdisk_hdr));
-	}
-	// Main header
-	lseek(fd, 0, SEEK_SET);
-	restore_buf(fd, &hdr, sizeof(hdr));
-
-	// Print new image info
-	print_info();
-
-	munmap(orig, size);
-	close(fd);
-}

jni/magiskboot/types.c

@@ -0,0 +1,83 @@
+#include <string.h>
+
+#include "bootimg.h"
+#include "types.h"
+
+char *SUP_LIST[] = { "gzip", "xz", "lzma", "bzip2", "lz4", "lz4_legacy", NULL };
+char *SUP_EXT_LIST[] = { "gz", "xz", "lzma", "bz2", "lz4", "lz4", NULL };
+file_t SUP_TYPE_LIST[] = { GZIP, XZ, LZMA, BZIP2, LZ4, LZ4_LEGACY, 0 };
+
+file_t check_type(const void *buf) {
+	if (memcmp(buf, CHROMEOS_MAGIC, 8) == 0) {
+		return CHROMEOS;
+	} else if (memcmp(buf, BOOT_MAGIC, BOOT_MAGIC_SIZE) == 0) {
+		return AOSP;
+	} else if (memcmp(buf, ELF32_MAGIC, 5) == 0) {
+		return ELF32;
+	} else if (memcmp(buf, ELF64_MAGIC, 5) == 0) {
+		return ELF64;
+	} else if (memcmp(buf, GZIP_MAGIC, 4) == 0) {
+		return GZIP;
+	} else if (memcmp(buf, LZOP_MAGIC, 9) == 0) {
+		return LZOP;
+	} else if (memcmp(buf, XZ_MAGIC, 6) == 0) {
+		return XZ;
+	} else if (memcmp(buf, "\x5d\x00\x00", 3) == 0
+			&& (((char *)buf)[12] == '\xff' || ((char *)buf)[12] == '\x00')) {
+		return LZMA;
+	} else if (memcmp(buf, BZIP_MAGIC, 3) == 0) {
+		return BZIP2;
+	} else if (memcmp(buf, LZ4_MAGIC, 4) == 0) {
+		return LZ4;
+	} else if (memcmp(buf, LZ4_LEG_MAGIC, 4) == 0) {
+		return LZ4_LEGACY;
+	} else if (memcmp(buf, MTK_MAGIC, 4) == 0) {
+		return MTK;
+	} else if (memcmp(buf, DTB_MAGIC, 4) == 0) {
+		return DTB;
+	} else {
+		return UNKNOWN;
+	}
+}
+
+void get_type_name(file_t type, char *name) {
+	char *s;
+	switch (type) {
+		case CHROMEOS:
+			s = "chromeos";
+			break;
+		case AOSP:
+			s = "aosp";
+			break;
+		case GZIP:
+			s = "gzip";
+			break;
+		case LZOP:
+			s = "lzop";
+			break;
+		case XZ:
+			s = "xz";
+			break;
+		case LZMA:
+			s = "lzma";
+			break;
+		case BZIP2:
+			s = "bzip2";
+			break;
+		case LZ4:
+			s = "lz4";
+			break;
+		case LZ4_LEGACY:
+			s = "lz4_legacy";
+			break;
+		case MTK:
+			s = "mtk";
+			break;
+		case DTB:
+			s = "dtb";
+			break;
+		default:
+			s = "raw";
+	}
+	strcpy(name, s);
+}

jni/magiskboot/types.h

@@ -0,0 +1,43 @@
+#ifndef _TYPES_H_
+#define _TYPES_H_
+
+typedef enum {
+    UNKNOWN,
+    CHROMEOS,
+    AOSP,
+    ELF32,
+    ELF64,
+    GZIP,
+    LZOP,
+    XZ,
+    LZMA,
+    BZIP2,
+    LZ4,
+    LZ4_LEGACY,
+    MTK,
+    DTB
+} file_t;
+
+#define COMPRESSED(type)  (type >= GZIP && type <= LZ4_LEGACY)
+
+#define CHROMEOS_MAGIC  "CHROMEOS"
+#define ELF32_MAGIC     "\x7f""ELF\x01"
+#define ELF64_MAGIC     "\x7f""ELF\x02"
+#define GZIP_MAGIC      "\x1f\x8b\x08\x00"
+#define LZOP_MAGIC      "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a"
+#define XZ_MAGIC        "\xfd""7zXZ\x00"
+#define BZIP_MAGIC      "BZh"
+#define LZ4_MAGIC       "\x04\x22\x4d\x18"
+#define LZ4_LEG_MAGIC   "\x02\x21\x4c\x18"
+#define MTK_MAGIC       "\x88\x16\x88\x58"
+#define DTB_MAGIC       "\xd0\x0d\xfe\xed"
+#define LG_BUMP_MAGIC   "\x41\xa9\xe4\x67\x74\x4d\x1d\x1b\xa4\x29\xf2\xec\xea\x65\x52\x79"
+
+extern char *SUP_LIST[];
+extern char *SUP_EXT_LIST[];
+extern file_t SUP_TYPE_LIST[];
+
+file_t check_type(const void *buf);
+void get_type_name(file_t type, char *name);
+
+#endif

jni/magiskboot/unpack.c

@@ -1,48 +0,0 @@
-#include "magiskboot.h"
-
-static void dump(unsigned char *buf, size_t size, const char *filename) {
-	int fd = open_new(filename);
-	xwrite(fd, buf, size);
-	close(fd);
-}
-
-void unpack(const char* image) {
-	size_t size;
-	unsigned char *orig;
-	mmap_ro(image, &orig, &size);
-
-	// Parse image
-	printf("Parsing boot image: [%s]\n\n", image);
-	parse_img(orig, size);
-
-	// Dump kernel
-	if (mtk_kernel) {
-		kernel += 512;
-		hdr.kernel_size -= 512;
-	}
-	dump(kernel, hdr.kernel_size, KERNEL_FILE);
-
-	// Dump ramdisk
-	if (mtk_ramdisk) {
-		ramdisk += 512;
-		hdr.ramdisk_size -= 512;
-	}
-	if (decomp(ramdisk_type, RAMDISK_FILE, ramdisk, hdr.ramdisk_size)) {
-		// Dump the compressed ramdisk
-		dump(ramdisk, hdr.ramdisk_size, RAMDISK_FILE ".unsupport");
-		LOGE(1, "Unsupported ramdisk format! Dumped to %s\n", RAMDISK_FILE ".unsupport");
-	}
-
-	if (hdr.second_size) {
-		// Dump second
-		dump(second, hdr.second_size, SECOND_FILE);
-	}
-
-	if (hdr.dt_size) {
-		// Dump dtb
-		dump(dtb, hdr.dt_size, DTB_FILE);
-	}
-
-	munmap(orig, size);
-}
-

jni/magiskboot/utils.c

@@ -1,146 +0,0 @@
-#include "magiskboot.h"
-
-char *SUP_LIST[] = { "gzip", "xz", "lzma", "bzip2", "lz4", "lz4_legacy", NULL };
-char *SUP_EXT_LIST[] = { "gz", "xz", "lzma", "bz2", "lz4", "lz4", NULL };
-file_t SUP_TYPE_LIST[] = { GZIP, XZ, LZMA, BZIP2, LZ4, LZ4_LEGACY, 0 };
-
-void mmap_ro(const char *filename, unsigned char **buf, size_t *size) {
-	int fd = xopen(filename, O_RDONLY);
-	*size = lseek(fd, 0, SEEK_END);
-	lseek(fd, 0, SEEK_SET);
-	*buf = xmmap(NULL, *size, PROT_READ, MAP_SHARED, fd, 0);
-	close(fd);
-}
-
-void mmap_rw(const char *filename, unsigned char **buf, size_t *size) {
-	int fd = xopen(filename, O_RDWR);
-	*size = lseek(fd, 0, SEEK_END);
-	lseek(fd, 0, SEEK_SET);
-	*buf = xmmap(NULL, *size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-	close(fd);
-}
-
-file_t check_type(const unsigned char *buf) {
-	if (memcmp(buf, CHROMEOS_MAGIC, 8) == 0) {
-		return CHROMEOS;
-	} else if (memcmp(buf, BOOT_MAGIC, BOOT_MAGIC_SIZE) == 0) {
-		return AOSP;
-	} else if (memcmp(buf, ELF32_MAGIC, 5) == 0) {
-		return ELF32;
-	} else if (memcmp(buf, ELF64_MAGIC, 5) == 0) {
-		return ELF64;
-	} else if (memcmp(buf, "\x1f\x8b\x08\x00", 4) == 0) {
-		return GZIP;
-	} else if (memcmp(buf, "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a", 9) == 0) {
-		return LZOP;
-	} else if (memcmp(buf, "\xfd""7zXZ\x00", 6) == 0) {
-		return XZ;
-	} else if (memcmp(buf, "\x5d\x00\x00", 3) == 0 
-			&& (buf[12] == (unsigned char) '\xff' || buf[12] == (unsigned char) '\x00')) {
-		return LZMA;
-	} else if (memcmp(buf, "BZh", 3) == 0) {
-		return BZIP2;
-	} else if (memcmp(buf, "\x04\x22\x4d\x18", 4) == 0) {
-		return LZ4;
-	} else if (memcmp(buf, "\x02\x21\x4c\x18", 4) == 0) {
-		return LZ4_LEGACY;
-	} else if (memcmp(buf, "\x88\x16\x88\x58", 4) == 0) {
-		return MTK;
-	} else {
-		return UNKNOWN;
-	}
-}
-
-void write_zero(int fd, size_t size) {
-	size_t pos = lseek(fd, 0, SEEK_CUR);
-	ftruncate(fd, pos + size);
-	lseek(fd, pos + size, SEEK_SET);
-}
-
-void mem_align(size_t *pos, size_t align) {
-	size_t mask = align - 1;
-	if (*pos & mask) {
-		*pos += align - (*pos & mask);
-	}
-}
-
-void file_align(int fd, size_t align, int out) {
-	size_t pos = lseek(fd, 0, SEEK_CUR);
-	size_t mask = align - 1;
-	size_t off;
-	if (pos & mask) {
-		off = align - (pos & mask);
-		if (out) {
-			write_zero(fd, off);
-		} else {
-			lseek(fd, pos + off, SEEK_SET);
-		}
-	}
-}
-
-int open_new(const char *filename) {
-	return xopen(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-}
-
-void print_info() {
-	printf("KERNEL [%d] @ 0x%08x\n", hdr.kernel_size, hdr.kernel_addr);
-	printf("RAMDISK [%d] @ 0x%08x\n", hdr.ramdisk_size, hdr.ramdisk_addr);
-	printf("SECOND [%d] @ 0x%08x\n", hdr.second_size, hdr.second_addr);
-	printf("DTB [%d] @ 0x%08x\n", hdr.dt_size, hdr.tags_addr);
-	printf("PAGESIZE [%d]\n", hdr.page_size);
-	if (hdr.os_version != 0) {
-		int a,b,c,y,m = 0;
-		int os_version, os_patch_level;
-		os_version = hdr.os_version >> 11;
-		os_patch_level = hdr.os_version & 0x7ff;
-		
-		a = (os_version >> 14) & 0x7f;
-		b = (os_version >> 7) & 0x7f;
-		c = os_version & 0x7f;
-		printf("OS_VERSION [%d.%d.%d]\n", a, b, c);
-		
-		y = (os_patch_level >> 4) + 2000;
-		m = os_patch_level & 0xf;
-		printf("PATCH_LEVEL [%d-%02d]\n", y, m);
-	}
-	printf("NAME [%s]\n", hdr.name);
-	printf("CMDLINE [%s]\n", hdr.cmdline);
-
-	switch (ramdisk_type) {
-		case GZIP:
-			printf("COMPRESSION [%s]\n", "gzip");
-			break;
-		case XZ:
-			printf("COMPRESSION [%s]\n", "xz");
-			break;
-		case LZMA:
-			printf("COMPRESSION [%s]\n", "lzma");
-			break;
-		case BZIP2:
-			printf("COMPRESSION [%s]\n", "bzip2");
-			break;
-		case LZ4:
-			printf("COMPRESSION [%s]\n", "lz4");
-			break;
-		case LZ4_LEGACY:
-			printf("COMPRESSION [%s]\n", "lz4_legacy");
-			break;
-		default:
-			fprintf(stderr, "Unknown ramdisk format!\n");
-	}
-	printf("\n");
-}
-
-void cleanup() {
-	printf("Cleaning up...\n");
-	char name[PATH_MAX];
-	unlink(KERNEL_FILE);
-	unlink(RAMDISK_FILE);
-	unlink(RAMDISK_FILE ".unsupport");
-	unlink(SECOND_FILE);
-	unlink(DTB_FILE);
-	for (int i = 0; SUP_EXT_LIST[i]; ++i) {
-		sprintf(name, "%s.%s", RAMDISK_FILE, SUP_EXT_LIST[i]);
-		unlink(name);
-	}
-}

jni/magiskhide/hide_daemon.c

@@ -1,127 +0,0 @@
-/* hide_daemon.c - MagiskHide daemon
- *
- * A dedicated process to join the target namespace,
- * and hide all traces in that particular namespace
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-
-#include "magisk.h"
-#include "utils.h"
-#include "magiskhide.h"
-
-static int pid;
-
-static void lazy_unmount(const char* mountpoint) {
-	if (umount2(mountpoint, MNT_DETACH) != -1)
-		LOGI("hide_daemon: Unmounted (%s)\n", mountpoint);
-	else
-		LOGI("hide_daemon: Unmount Failed (%s)\n", mountpoint);
-}
-
-static void hide_daemon_err() {
-	LOGD("hide_daemon: error occured, stopping magiskhide services\n");
-	// Resume process if possible
-	kill(pid, SIGCONT);
-	int err = 1;
-	write(sv[1], &err, sizeof(err));
-	_exit(-1);
-}
-
-int hide_daemon() {
-	// Fork to a new process
-	hide_pid = fork();
-	switch(hide_pid) {
-	case -1:
-		PLOGE("fork");
-		return 1;
-	case 0:
-		break;
-	default:
-		return 0;
-	}
-
-	close(sv[0]);
-
-	// Set the process name
-	strcpy(argv0, "magiskhide_daemon");
-	// When an error occurs, report its failure to main process
-	err_handler = hide_daemon_err;
-	
-	char buffer[4096], cache_block[256], *line;
-	struct vector mount_list;
-	
-	cache_block[0] = '\0';
-
-	while(1) {
-		xxread(sv[1], &pid, sizeof(pid));
-		// Termination called
-		if(pid == -1) {
-			LOGD("hide_daemon: received termination request\n");
-			_exit(0);
-		}
-
-		manage_selinux();
-		relink_sbin();
-
-		if (switch_mnt_ns(pid))
-			continue;
-
-		snprintf(buffer, sizeof(buffer), "/proc/%d/mounts", pid);
-		vec_init(&mount_list);
-		file_to_vector(buffer, &mount_list);
-
-		// Find the cache block name if not found yet
-		if (strlen(cache_block) == 0) {
-			vec_for_each(&mount_list, line) {
-				if (strstr(line, " /cache ")) {
-					sscanf(line, "%256s", cache_block);
-					break;
-				}
-			}
-		}
-
-		// First unmount the dummy skeletons, cache mounts, and /sbin links
-		vec_for_each_r(&mount_list, line) {
-			if (strstr(line, "tmpfs /system") || strstr(line, "tmpfs /vendor") || strstr(line, "tmpfs /sbin")
-				|| (strstr(line, cache_block) && strstr(line, "/system/")) ) {
-				sscanf(line, "%*s %512s", buffer);
-				lazy_unmount(buffer);
-			}
-			free(line);
-		}
-		vec_destroy(&mount_list);
-
-		// Re-read mount infos
-		snprintf(buffer, sizeof(buffer), "/proc/%d/mounts", pid);
-		vec_init(&mount_list);
-		file_to_vector(buffer, &mount_list);
-
-		// Unmount loop mounts
-		vec_for_each_r(&mount_list, line) {
-			if (strstr(line, "/dev/block/loop") && !strstr(line, DUMMDIR)) {
-				sscanf(line, "%*s %512s", buffer);
-				lazy_unmount(buffer);
-			}
-			free(line);
-		}
-		vec_destroy(&mount_list);
-
-		// All done, send resume signal
-		kill(pid, SIGCONT);
-
-		// Tell main process all is well
-		pid = 0;
-		xwrite(sv[1], &pid, sizeof(pid));
-	}
-
-	// Should never go here
-}

jni/magiskhide/hide_utils.c

@@ -1,14 +1,73 @@
-/* list_manager.c - Hide list management
+/* hide_utils.c - Some utility functions for MagiskHide
  */
 
-#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <unistd.h>
-#include <pthread.h>
+#include <errno.h>
+#include <dirent.h>
+#include <string.h>
+#include <sys/mount.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <selinux/selinux.h>
 
 #include "magisk.h"
 #include "utils.h"
-#include "daemon.h"
+#include "resetprop.h"
 #include "magiskhide.h"
+#include "daemon.h"
+
+static char *prop_key[] =
+	{ "ro.boot.verifiedbootstate", "ro.boot.flash.locked", "ro.boot.veritymode", "ro.boot.warranty_bit", "ro.warranty_bit",
+	  "ro.debuggable", "ro.secure", "ro.build.type", "ro.build.tags", "ro.build.selinux", NULL };
+
+static char *prop_value[] =
+	{ "green", "1", "enforcing", "0", "0", "0", "1", "user", "release-keys", "0", NULL };
+
+static int mocked = 0;
+
+void manage_selinux() {
+	if (mocked) return;
+	char val[1];
+	int fd = xopen(SELINUX_ENFORCE, O_RDONLY);
+	xxread(fd, val, 1);
+	close(fd);
+	// Permissive
+	if (val[0] == '0') {
+		LOGI("hide_daemon: Permissive detected, hide the state\n");
+
+		chmod(SELINUX_ENFORCE, 0640);
+		chmod(SELINUX_POLICY, 0440);
+		mocked = 1;
+	}
+}
+
+void hide_sensitive_props() {
+	LOGI("hide_utils: Hiding sensitive props\n");
+
+	// Hide all sensitive props
+	char *value;
+	for (int i = 0; prop_key[i]; ++i) {
+		value = getprop(prop_key[i]);
+		if (value) {
+			if (strcmp(value, prop_value[i]) != 0)
+				setprop2(prop_key[i], prop_value[i], 0);
+			free(value);
+		}
+	}
+}
+
+static void rm_magisk_prop(const char *name, const char *value) {
+	if (strstr(name, "magisk")) {
+		deleteprop2(name, 0);
+	}
+}
+
+void clean_magisk_props() {
+	LOGD("hide_utils: Cleaning magisk props\n");
+	getprop_all(rm_magisk_prop);
+}
 
 int add_list(char *proc) {
 	if (!hideEnabled) {
@@ -45,10 +104,7 @@ int add_list(char *proc) {
 	pthread_mutex_unlock(&hide_lock);
 
 	pthread_mutex_lock(&file_lock);
-	if (vector_to_file(HIDELIST, hide_list)) {
-		pthread_mutex_unlock(&file_lock);
-		return DAEMON_ERROR;
-	}
+	vector_to_file(HIDELIST, hide_list); // Do not complain if file not found
 	pthread_mutex_unlock(&file_lock);
 	return DAEMON_SUCCESS;
 }
@@ -89,8 +145,7 @@ int rm_list(char *proc) {
 
 		ret = DAEMON_SUCCESS;
 		pthread_mutex_lock(&file_lock);
-		if (vector_to_file(HIDELIST, hide_list))
-			ret = DAEMON_ERROR;
+		vector_to_file(HIDELIST, hide_list); // Do not complain if file not found
 		pthread_mutex_unlock(&file_lock);
 	} else {
 		ret = HIDE_ITEM_NOT_EXIST;
@@ -132,7 +187,6 @@ int destroy_list() {
 }
 
 void add_hide_list(int client) {
-	err_handler = do_nothing;
 	char *proc = read_string(client);
 	// ack
 	write_int(client, add_list(proc));
@@ -140,9 +194,22 @@ void add_hide_list(int client) {
 }
 
 void rm_hide_list(int client) {
-	err_handler = do_nothing;
 	char *proc = read_string(client);
 	// ack
 	write_int(client, rm_list(proc));
 	close(client);
 }
+
+void ls_hide_list(int client) {
+	if (!hideEnabled) {
+		write_int(client, HIDE_NOT_ENABLED);
+		return;
+	}
+	write_int(client, DAEMON_SUCCESS);
+	write_int(client, vec_size(hide_list));
+	char *s;
+	vec_for_each(hide_list, s) {
+		write_string(client, s);
+	}
+	close(client);
+}

jni/magiskhide/magiskhide.c

@@ -16,7 +16,6 @@
 #include "daemon.h"
 #include "resetprop.h"
 
-int sv[2], hide_pid = -1;
 struct vector *hide_list = NULL;
 
 int hideEnabled = 0;
@@ -29,52 +28,34 @@ void kill_proc(int pid) {
 
 static void usage(char *arg0) {
 	fprintf(stderr,
-		"MagiskHide v" xstr(MAGISK_VERSION) " (by topjohnwu) - Hide Magisk!\n\n"
-		"%s [--options [arguments...] ]\n\n"
+		"MagiskHide v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") (by topjohnwu) - Hide Magisk!\n\n"
+		"Usage: %s [--options [arguments...] ]\n\n"
 		"Options:\n"
-		"  --enable: Start the magiskhide daemon\n"
-		"  --disable: Stop the magiskhide daemon\n"
-		"  --add <process name>: Add <process name> to the list\n"
-		"  --rm <process name>: Remove <process name> from the list\n"
-		"  --ls: Print out the current hide list\n"
+		"  --enable          Start magiskhide\n"
+		"  --disable         Stop magiskhide\n"
+		"  --add PROCESS     Add PROCESS to the hide list\n"
+		"  --rm PROCESS      Remove PROCESS from the hide list\n"
+		"  --ls              Print out the current hide list\n"
 		, arg0);
 	exit(1);
 }
 
 void launch_magiskhide(int client) {
-	// We manually handle crashes
-	err_handler = do_nothing;
-
 	if (hideEnabled) {
-		write_int(client, HIDE_IS_ENABLED);
-		close(client);
+		if (client > 0) {
+			write_int(client, HIDE_IS_ENABLED);
+			close(client);
+		}
 		return;
 	}
 
+	hideEnabled = 1;
 	LOGI("* Starting MagiskHide\n");
 
-	hideEnabled = 1;
-
-	if (client != -1) {
-		if (setprop(MAGISKHIDE_PROP, "1"))
-			goto error;
-	}
+	deleteprop2(MAGISKHIDE_PROP, 1);
 
 	hide_sensitive_props();
 
-	if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sv) == -1)
-		goto error;
-
-	/*
-	 * The setns system call do not support multithread processes
-	 * We have to fork a new process, and communicate with sockets
-	 */
-
-	if (hide_daemon())
-		goto error;
-
-	close(sv[1]);
-
 	// Initialize the mutex lock
 	pthread_mutex_init(&hide_lock, NULL);
 	pthread_mutex_init(&file_lock, NULL);
@@ -86,8 +67,10 @@ void launch_magiskhide(int client) {
 	// Add SafetyNet by default
 	add_list(strdup("com.google.android.gms.unstable"));
 
-	write_int(client, DAEMON_SUCCESS);
-	close(client);
+	if (client > 0) {
+		write_int(client, DAEMON_SUCCESS);
+		close(client);
+	}
 
 	// Get thread reference
 	proc_monitor_thread = pthread_self();
@@ -97,15 +80,9 @@ void launch_magiskhide(int client) {
 
 error:
 	hideEnabled = 0;
-	write_int(client, DAEMON_ERROR);
-	close(client);
-	if (hide_pid != -1) {
-		int kill = -1;
-		// Kill hide daemon
-		write(sv[0], &kill, sizeof(kill));
-		close(sv[0]);
-		waitpid(hide_pid, NULL, 0);
-		hide_pid = -1;
+	if (client > 0) {
+		write_int(client, DAEMON_ERROR);
+		close(client);
 	}
 	return;
 }
@@ -121,7 +98,9 @@ void stop_magiskhide(int client) {
 
 	hideEnabled = 0;
 	setprop(MAGISKHIDE_PROP, "0");
-	pthread_kill(proc_monitor_thread, SIGUSR1);
+	// Remove without actually removing persist props
+	deleteprop2(MAGISKHIDE_PROP, 0);
+	pthread_kill(proc_monitor_thread, TERM_THREAD);
 
 	write_int(client, DAEMON_SUCCESS);
 	close(client);
@@ -141,15 +120,9 @@ int magiskhide_main(int argc, char *argv[]) {
 	} else if (strcmp(argv[1], "--rm") == 0 && argc > 2) {
 		req = RM_HIDELIST;
 	} else if (strcmp(argv[1], "--ls") == 0) {
-		FILE *fp = fopen(HIDELIST, "r");
-		if (fp == NULL)
-			return 1;
-		char buffer[512];
-		while (fgets(buffer, sizeof(buffer), fp)) {
-			printf("%s", buffer);
-		}
-		fclose(fp);
-		return 0;
+		req = LS_HIDELIST;
+	} else {
+		usage(argv[0]);
 	}
 	int fd = connect_daemon();
 	write_int(fd, req);
@@ -157,28 +130,38 @@ int magiskhide_main(int argc, char *argv[]) {
 		write_string(fd, argv[2]);
 	}
 	daemon_response code = read_int(fd);
-	close(fd);
 	switch (code) {
 	case DAEMON_ERROR:
 		fprintf(stderr, "Error occured in daemon...\n");
-		break;
+		return code;
 	case DAEMON_SUCCESS:
 		break;
 	case ROOT_REQUIRED:
 		fprintf(stderr, "Root is required for this operation\n");
-		break;
+		return code;
 	case HIDE_NOT_ENABLED:
 		fprintf(stderr, "Magisk hide is not enabled yet\n");
-		break;
+		return code;
 	case HIDE_IS_ENABLED:
 		fprintf(stderr, "Magisk hide is already enabled\n");
-		break;
+		return code;
 	case HIDE_ITEM_EXIST:
 		fprintf(stderr, "Process [%s] already exists in hide list\n", argv[2]);
-		break;
+		return code;
 	case HIDE_ITEM_NOT_EXIST:
 		fprintf(stderr, "Process [%s] does not exist in hide list\n", argv[2]);
-		break;
+		return code;
 	}
-	return code;
+
+	if (req == LS_HIDELIST) {
+		int argc = read_int(fd);
+		for (int i = 0; i < argc; ++i) {
+			char *s = read_string(fd);
+			printf("%s\n", s);
+			free(s);
+		}
+	}
+	close(fd);
+
+	return 0;
 }

jni/magiskhide/magiskhide.h

@@ -3,19 +3,19 @@
 
 #include <pthread.h>
 
+#define TERM_THREAD SIGUSR1
+#define HIDE_DONE   SIGUSR2
+
 // Kill process
 void kill_proc(int pid);
 
-// Hide daemon
-int hide_daemon();
-
 // Process monitor
 void proc_monitor();
 
-// Preprocess
+// Utility functions
 void manage_selinux();
 void hide_sensitive_props();
-void relink_sbin();
+void clean_magisk_props();
 
 // List managements
 int add_list(char *proc);
@@ -23,7 +23,7 @@ int rm_list(char *proc);
 int init_list();
 int destroy_list();
 
-extern int sv[2], hide_pid, hideEnabled;
+extern int hideEnabled;
 extern struct vector *hide_list;
 extern pthread_mutex_t hide_lock, file_lock;
 

jni/magiskhide/pre_process.c

@@ -1,90 +0,0 @@
-/* pre_process.c - Some pre-processes for MagiskHide to hide properly
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <dirent.h>
-#include <string.h>
-#include <sys/mount.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <selinux/selinux.h>
-
-#include "magisk.h"
-#include "utils.h"
-#include "resetprop.h"
-#include "magiskhide.h"
-
-static char *prop_key[] =
-	{ "ro.boot.verifiedbootstate", "ro.boot.flash.locked", "ro.boot.veritymode", "ro.boot.warranty_bit", "ro.warranty_bit", 
-	  "ro.debuggable", "ro.secure", NULL };
-
-static char *prop_value[] =
-	{ "green", "1", "enforcing", "0", "0", "0", "1", NULL };
-
-static int isMocked = 0;
-
-void manage_selinux() {
-	if (isMocked) return;
-	char val[1];
-	int fd = xopen(SELINUX_ENFORCE, O_RDONLY);
-	xxread(fd, val, 1);
-	close(fd);
-	// Permissive
-	if (val[0] == '0') {
-		LOGI("hide_daemon: Permissive detected, hide the state\n");
-
-		chmod(SELINUX_ENFORCE, 0640);
-		chmod(SELINUX_POLICY, 0440);
-		isMocked = 1;
-	}
-}
-
-void hide_sensitive_props() {
-	LOGI("hide_pre_proc: Hiding sensitive props\n");
-
-	// Hide all sensitive props
-	char *value;
-	for (int i = 0; prop_key[i]; ++i) {
-		value = getprop(prop_key[i]);
-		if (value) {
-			if (strcmp(value, prop_value[i]) != 0)
-				setprop2(prop_key[i], prop_value[i], 0);
-			free(value);
-		}
-	}
-}
-
-void relink_sbin() {
-	struct stat st;
-	if (stat("/sbin_orig", &st) == -1 && errno == ENOENT) {
-		// Re-link all binaries and bind mount 
-		DIR *dir;
-		struct dirent *entry;
-		char from[PATH_MAX], to[PATH_MAX];
-
-		LOGI("hide_pre_proc: Re-linking /sbin\n");
-
-		xmount(NULL, "/", NULL, MS_REMOUNT, NULL);
-		xrename("/sbin", "/sbin_orig");
-		xmkdir("/sbin", 0755);
-		xchmod("/sbin", 0755);
-		xmount(NULL, "/", NULL, MS_REMOUNT | MS_RDONLY, NULL);
-		xmkdir("/dev/sbin_bind", 0755);
-		xchmod("/dev/sbin_bind", 0755);
-		dir = xopendir("/sbin_orig");
-
-		while ((entry = xreaddir(dir))) {
-			snprintf(from, sizeof(from), "%s/%s", "/sbin_orig", entry->d_name);
-			snprintf(to, sizeof(to), "%s/%s", "/dev/sbin_bind", entry->d_name);
-			symlink(from, to);
-			lsetfilecon(to, "u:object_r:system_file:s0");
-		}
-		
-		closedir(dir);
-
-		xmount("/dev/sbin_bind", "/sbin", NULL, MS_BIND, NULL);
-	}
-}

jni/magiskhide/proc_monitor.c

@@ -1,7 +1,8 @@
-/* proc_monitor.c - Monitor am_proc_start events
- * 
- * We monitor the logcat am_proc_start events, pause it,
- * and send the target PID to hide daemon ASAP
+/* proc_monitor.c - Monitor am_proc_start events and unmount
+ *
+ * We monitor the logcat am_proc_start events. When a target starts up,
+ * we pause it ASAP, and fork a new process to join its mount namespace
+ * and do all the unmounting/mocking
  */
 
 #include <stdlib.h>
@@ -12,47 +13,49 @@
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <sys/mount.h>
 
 #include "magisk.h"
 #include "utils.h"
 #include "magiskhide.h"
 
-static int zygote_num = 0;
-static char init_ns[32], zygote_ns[2][32];
-static int log_pid = 0, log_fd = 0;
-static char *buffer;
-
-static void read_namespace(const int pid, char* target, const size_t size) {
-	char path[32];
-	snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
-	xreadlink(path, target, size);
-}
+static char init_ns[32], zygote_ns[2][32], cache_block[256];
+static int hide_queue = 0, zygote_num, has_cache = 1, pipefd[2] = { -1, -1 };
 
 // Workaround for the lack of pthread_cancel
-static void quit_pthread(int sig) {
-	err_handler = do_nothing;
+static void term_thread(int sig) {
 	LOGD("proc_monitor: running cleanup\n");
 	destroy_list();
-	free(buffer);
 	hideEnabled = 0;
-	// Kill the logging if needed
-	if (log_pid) {
-		kill(log_pid, SIGTERM);
-		waitpid(log_pid, NULL, 0);
-		close(log_fd);
-		log_fd = log_pid = 0;
-	}
-	int kill = -1;
-	// If process monitor dies, kill hide daemon too
-	write(sv[0], &kill, sizeof(kill));
-	close(sv[0]);
-	waitpid(hide_pid, NULL, 0);
+	// Unregister listener
+	logcat_events[HIDE_EVENT] = -1;
+	close(pipefd[0]);
+	close(pipefd[1]);
+	pipefd[0] = pipefd[1] = -1;
 	pthread_mutex_destroy(&hide_lock);
 	pthread_mutex_destroy(&file_lock);
 	LOGD("proc_monitor: terminating...\n");
 	pthread_exit(NULL);
 }
 
+static void hide_done(int sig) {
+	--hide_queue;
+	if (hide_queue == 0) {
+		xmount(NULL, "/", NULL, MS_REMOUNT, NULL);
+		xsymlink(MOUNTPOINT, FAKEPOINT);
+		xmount(NULL, "/", NULL, MS_REMOUNT | MS_RDONLY, NULL);
+	}
+}
+
+static int read_namespace(const int pid, char* target, const size_t size) {
+	char path[32];
+	snprintf(path, sizeof(path), "/proc/%d/ns/mnt", pid);
+	if (access(path, R_OK) == -1)
+		return 1;
+	xreadlink(path, target, size);
+	return 0;
+}
+
 static void store_zygote_ns(int pid) {
 	if (zygote_num == 2) return;
 	do {
@@ -62,29 +65,113 @@ static void store_zygote_ns(int pid) {
 	++zygote_num;
 }
 
-static void proc_monitor_err() {
-	LOGD("proc_monitor: error occured, stopping magiskhide services\n");
-	quit_pthread(SIGUSR1);
+static void lazy_unmount(const char* mountpoint) {
+	if (umount2(mountpoint, MNT_DETACH) != -1)
+		LOGD("hide_daemon: Unmounted (%s)\n", mountpoint);
+	else
+		LOGD("hide_daemon: Unmount Failed (%s)\n", mountpoint);
+}
+
+static void hide_daemon(int pid, int ppid) {
+	LOGD("hide_daemon: start unmount for pid=[%d]\n", pid);
+
+	char *line, buffer[PATH_MAX];
+	struct vector mount_list;
+
+	manage_selinux();
+	clean_magisk_props();
+
+	if (switch_mnt_ns(pid))
+		goto exit;
+
+	snprintf(buffer, sizeof(buffer), "/proc/%d/mounts", pid);
+	vec_init(&mount_list);
+	file_to_vector(buffer, &mount_list);
+
+	// Find the cache block name if not found yet
+	if (has_cache && cache_block[0] == '\0') {
+		vec_for_each(&mount_list, line) {
+			if (strstr(line, " /cache ")) {
+				sscanf(line, "%256s", cache_block);
+				break;
+			}
+		}
+		if (strlen(cache_block) == 0)
+			has_cache = 0;
+	}
+
+	// Unmout cache mounts
+	if (has_cache) {
+		vec_for_each(&mount_list, line) {
+			if (strstr(line, cache_block) && (strstr(line, " /system/") || strstr(line, " /vendor/"))) {
+				sscanf(line, "%*s %4096s", buffer);
+				lazy_unmount(buffer);
+			}
+		}
+	}
+
+	// Unmount dummy skeletons, /sbin links
+	vec_for_each(&mount_list, line) {
+		if (strstr(line, "tmpfs /system") || strstr(line, "tmpfs /vendor") || strstr(line, "tmpfs /sbin")) {
+			sscanf(line, "%*s %4096s", buffer);
+			lazy_unmount(buffer);
+		}
+		free(line);
+	}
+	vec_destroy(&mount_list);
+
+	// Re-read mount infos
+	snprintf(buffer, sizeof(buffer), "/proc/%d/mounts", pid);
+	vec_init(&mount_list);
+	file_to_vector(buffer, &mount_list);
+
+	// Unmount any loop mounts
+	vec_for_each(&mount_list, line) {
+		if (strstr(line, "/dev/block/loop")) {
+			sscanf(line, "%*s %4096s", buffer);
+			lazy_unmount(buffer);
+		}
+		free(line);
+	}
+
+exit:
+	// Send resume signal
+	kill(pid, SIGCONT);
+	// Free up memory
+	vec_destroy(&mount_list);
+	// Wait a while and link it back
+	sleep(10);
+	kill(ppid, HIDE_DONE);
+	_exit(0);
 }
 
 void proc_monitor() {
+	// Unblock user signals
+	sigset_t block_set;
+	sigemptyset(&block_set);
+	sigaddset(&block_set, TERM_THREAD);
+	sigaddset(&block_set, HIDE_DONE);
+	pthread_sigmask(SIG_UNBLOCK, &block_set, NULL);
+
 	// Register the cancel signal
 	struct sigaction act;
 	memset(&act, 0, sizeof(act));
-	act.sa_handler = quit_pthread;
-	sigaction(SIGUSR1, &act, NULL);
+	act.sa_handler = term_thread;
+	sigaction(TERM_THREAD, &act, NULL);
+	act.sa_handler = hide_done;
+	sigaction(HIDE_DONE, &act, NULL);
 
-	// The error handler should stop magiskhide services
-	err_handler = proc_monitor_err;
-
-	int pid;
-	buffer = xmalloc(PATH_MAX);
+	cache_block[0] = '\0';
 
 	// Get the mount namespace of init
-	read_namespace(1, init_ns, 32);
+	if (read_namespace(1, init_ns, 32)) {
+		LOGE("proc_monitor: Your kernel doesn't support mount namespace :(\n");
+		term_thread(TERM_THREAD);
+	}
 	LOGI("proc_monitor: init ns=%s\n", init_ns);
 
 	// Get the mount namespace of zygote
+	zygote_num = 0;
 	while(!zygote_num) {
 		// Check zygote every 2 secs
 		sleep(2);
@@ -97,21 +184,24 @@ void proc_monitor() {
 		LOGI("proc_monitor: zygote ns=%s\n", zygote_ns[0]);
 		break;
 	case 2:
-		LOGI("proc_monitor: zygote (32-bit) ns=%s (64-bit) ns=%s\n", zygote_ns[0], zygote_ns[1]);
+		LOGI("proc_monitor: zygote ns=%s zygote64 ns=%s\n", zygote_ns[0], zygote_ns[1]);
 		break;
 	}
 
-	while (1) {
-		// Clear previous buffer
-		system("logcat -b events -c");
+	// Register our listener to logcat monitor
+	xpipe2(pipefd, O_CLOEXEC);
+	logcat_events[HIDE_EVENT] = pipefd[1];
 
-		// Monitor am_proc_start
-		char *const command[] = { "logcat", "-b", "events", "-v", "raw", "-s", "am_proc_start", NULL };
-		log_pid = run_command(0, &log_fd, "/system/bin/logcat", command);
-
-		while(fdgets(buffer, PATH_MAX, log_fd)) {
-			int ret, comma = 0;
-			char *pos = buffer, *line, processName[256];
+	for (char *log, *line; 1; free(log)) {
+		if (read(pipefd[0], &log, sizeof(log)) != sizeof(log)) {
+			/* It might be interrupted */
+			log = NULL;
+			continue;
+		}
+		char *ss;
+		if ((ss = strstr(log, "am_proc_start")) && (ss = strchr(ss, '['))) {
+			int pid, ret, comma = 0;
+			char *pos = ss, processName[256], ns[32];
 
 			while(1) {
 				pos = strchr(pos, ',');
@@ -122,9 +212,9 @@ void proc_monitor() {
 			}
 
 			if (comma == 6)
-				ret = sscanf(buffer, "[%*d %d %*d %*d %256s", &pid, processName);
+				ret = sscanf(ss, "[%*d %d %*d %*d %256s", &pid, processName);
 			else
-				ret = sscanf(buffer, "[%*d %d %*d %256s", &pid, processName);
+				ret = sscanf(ss, "[%*d %d %*d %256s", &pid, processName);
 
 			if(ret != 2)
 				continue;
@@ -138,8 +228,8 @@ void proc_monitor() {
 					while(1) {
 						ret = 1;
 						for (int i = 0; i < zygote_num; ++i) {
-							read_namespace(pid, buffer, 32);
-							if (strcmp(buffer, zygote_ns[i]) == 0) {
+							read_namespace(pid, ns, sizeof(ns));
+							if (strcmp(ns, zygote_ns[i]) == 0) {
 								usleep(50);
 								ret = 0;
 								break;
@@ -148,35 +238,28 @@ void proc_monitor() {
 						if (ret) break;
 					}
 
-					ret = 0;
-
 					// Send pause signal ASAP
 					if (kill(pid, SIGSTOP) == -1) continue;
 
-					LOGI("proc_monitor: %s (PID=%d ns=%s)\n", processName, pid, buffer);
+					LOGI("proc_monitor: %s (PID=%d ns=%s)\n", processName, pid, ns);
 
-					// Unmount start
-					xwrite(sv[0], &pid, sizeof(pid));
+					/*
+					 * The setns system call do not support multithread processes
+					 * We have to fork a new process, setns, then do the unmounts
+					 */
+					xmount(NULL, "/", NULL, MS_REMOUNT, NULL);
+					unlink(FAKEPOINT);
+					unlink(MAGISKRC);
+					xmount(NULL, "/", NULL, MS_REMOUNT | MS_RDONLY, NULL);
+					++hide_queue;
+					int selfpid = getpid();
+					if (fork_dont_care() == 0)
+						hide_daemon(pid, selfpid);
 
-					// Get the hide daemon return code
-					xxread(sv[0], &ret, sizeof(ret));
-					LOGD("proc_monitor: hide daemon response code: %d\n", ret);
 					break;
 				}
 			}
 			pthread_mutex_unlock(&hide_lock);
-
-			if (ret) {
-				// Wait hide process to kill itself
-				waitpid(hide_pid, NULL, 0);
-				quit_pthread(SIGUSR1);
-			}
 		}
-
-		// For some reason it went here, restart logging
-		kill(log_pid, SIGTERM);
-		waitpid(log_pid, NULL, 0);
-		close(log_fd);
-		log_pid = 0;
 	}
 }

jni/main.c

@@ -1,145 +0,0 @@
-/* main.c - The multicall entry point
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "utils.h"
-#include "magisk.h"
-#include "daemon.h"
-
-char *argv0;
-
-char *applet[] =
-	{ "su", "resetprop", "magiskpolicy", "supolicy", "sepolicy-inject", "magiskhide", NULL };
-
-int (*applet_main[]) (int, char *[]) =
-	{ su_client_main, resetprop_main, magiskpolicy_main, magiskpolicy_main, magiskpolicy_main, magiskhide_main, NULL };
-
-// Global error hander function
-// Should be changed each thread/process
-__thread void (*err_handler)(void);
-
-static void usage() {
-	fprintf(stderr,
-		"Magisk v" xstr(MAGISK_VERSION) " multi-call binary\n"
-		"\n"
-		"Usage: %s [applet [arguments]...]\n"
-		"   or: %s --install [SOURCE] <DIR> \n"
-		"   or: %s --list\n"
-		"   or: %s --createimg <PATH> <SIZE>\n"
-		"       create ext4 image, SIZE is interpreted in MB\n"
-		"   or: %s --imgsize <PATH>\n"
-		"   or: %s --resizeimg <PATH> <SIZE>\n"
-		"       SIZE is interpreted in MB\n"
-		"   or: %s --[boot stage]\n"
-		"       start boot stage service\n"
-		"   or: %s [options]\n"
-		"   or: applet [arguments]...\n"
-		"\n"
-		"Supported boot stages:\n"
-		"       post-fs, post-fs-data, service\n"
-		"\n"
-		"Options:\n"
-		"       -c            print client version\n"
-		"       -v            print daemon version\n"
-		"       -V            print daemon version code\n"
-		"\n"
-		"Supported applets:\n"
-	, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0);
-
-	for (int i = 0; applet[i]; ++i) {
-		fprintf(stderr, i ? ", %s" : "       %s", applet[i]);
-	}
-	fprintf(stderr, "\n");
-	exit(1);
-}
-
-int main(int argc, char *argv[]) {
-	argv0 = argv[0];
-	// Exit the whole app if error occurs by default
-	err_handler = exit_proc;
-	char * arg = strrchr(argv[0], '/');
-	if (arg) ++arg;
-	else arg = argv[0];
-	if (strcmp(arg, "magisk") == 0) {
-		if (argc < 2) usage();
-		if (strcmp(argv[1], "-c") == 0) {
-			printf("%s\n", MAGISK_VER_STR);
-			return 0;
-		} else if (strcmp(argv[1], "-v") == 0) {
-			int fd = connect_daemon();
-			write_int(fd, CHECK_VERSION);
-			char *v = read_string(fd);
-			printf("%s\n", v);
-			free(v);
-			return 0;
-		} else if (strcmp(argv[1], "-V") == 0) {
-			int fd = connect_daemon();
-			write_int(fd, CHECK_VERSION_CODE);
-			printf("%d\n", read_int(fd));
-			return 0;
-		} else if (strcmp(argv[1], "--install") == 0) {
-			if (argc < 3) usage();
-			if (argc == 3) return create_links(NULL, argv[2]);
-			else return create_links(argv[2], argv[3]);
-		} else if (strcmp(argv[1], "--list") == 0) {
-			for (int i = 0; applet[i]; ++i)
-				printf("%s\n", applet[i]);
-			return 0;
-		} else if (strcmp(argv[1], "--createimg") == 0) {
-			if (argc < 4) usage();
-			int size;
-			sscanf(argv[3], "%d", &size);
-			return create_img(argv[2], size);
-		} else if (strcmp(argv[1], "--imgsize") == 0) {
-			if (argc < 3) usage();
-			int used, total;
-			if (get_img_size(argv[2], &used, &total)) {
-				fprintf(stderr, "Cannot check %s size\n", argv[2]);
-				return 1;
-			}
-			printf("Used: %dM\tTotal: %dM\n", used, total);
-			return 0;
-		} else if (strcmp(argv[1], "--resizeimg") == 0) {
-			if (argc < 4) usage();
-			int used, total, size;
-			sscanf(argv[3], "%d", &size);
-			if (get_img_size(argv[2], &used, &total)) {
-				fprintf(stderr, "Cannot check %s size\n", argv[2]);
-				return 1;
-			}
-			if (size <= used) {
-				fprintf(stderr, "Cannot resize smaller than %dM\n", used);
-				return 1;
-			}
-			return resize_img(argv[2], size);
-		} else if (strcmp(argv[1], "--post-fs") == 0) {
-			int fd = connect_daemon();
-			write_int(fd, POST_FS);
-			return read_int(fd);
-		} else if (strcmp(argv[1], "--post-fs-data") == 0) {
-			int fd = connect_daemon();
-			write_int(fd, POST_FS_DATA);
-			return read_int(fd);
-		} else if (strcmp(argv[1], "--service") == 0) {
-			int fd = connect_daemon();
-			write_int(fd, LATE_START);
-			return read_int(fd);
-		} else {
-			// It's calling applets
-			--argc;
-			++argv;
-			arg = argv[0];
-		}
-	}
-
-	// Applets
-	for (int i = 0; applet[i]; ++i) {
-		if (strcmp(arg, applet[i]) == 0)
-			return (*applet_main[i])(argc, argv);
-	}
-
-	fprintf(stderr, "%s: applet not found\n", arg);
-	return 1;
-}

jni/resetprop/Android.mk

@@ -1,8 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := resetprop
-LOCAL_SRC_FILES := resetprop.cpp system_properties.cpp libc_logging.cpp
-LOCAL_LDLIBS += -latomic
-LOCAL_CFLAGS := -Wno-implicit-exception-spec-mismatch -DINDEP_BINARY
-include $(BUILD_EXECUTABLE)

jni/resetprop/_system_properties.h

@@ -73,22 +73,22 @@ int __system_property_area_init2();
 
 /* Read the global serial number of the system properties
 **
-** Called to predict if a series of cached __system_property_find2
-** objects will have seen __system_property_serial2 values change.
+** Called to predict if a series of cached __system_property_find
+** objects will have seen __system_property_serial values change.
 ** But also aids the converse, as changes in the global serial can
-** also be used to predict if a failed __system_property_find2
+** also be used to predict if a failed __system_property_find
 ** could in-turn now find a new object; thus preventing the
-** cycles of effort to poll __system_property_find2.
+** cycles of effort to poll __system_property_find.
 **
 ** Typically called at beginning of a cache cycle to signal if _any_ possible
 ** changes have occurred since last. If there is, one may check each individual
-** __system_property_serial2 to confirm dirty, or __system_property_find2
-** to check if the property now exists. If a call to __system_property_add2
-** or __system_property_update2 has completed between two calls to
-** __system_property_area_serial2 then the second call will return a larger
+** __system_property_serial to confirm dirty, or __system_property_find
+** to check if the property now exists. If a call to __system_property_add
+** or __system_property_update has completed between two calls to
+** __system_property_area_serial then the second call will return a larger
 ** value than the first call. Beware of race conditions as changes to the
 ** properties are not atomic, the main value of this call is to determine
-** whether the expensive __system_property_find2 is worth retrying to see if
+** whether the expensive __system_property_find is worth retrying to see if
 ** a property now exists.
 **
 ** Returns the serial number on success, -1 on error.
@@ -112,7 +112,7 @@ int __system_property_add2(const char *name, unsigned int namelen, const char *v
 int __system_property_del(const char *name);
 
 /* Update the value of a system property returned by
-** __system_property_find2.  Can only be done by a single process
+** __system_property_find.  Can only be done by a single process
 ** that has write access to the property area, and that process
 ** must handle sequencing to ensure that only one property is
 ** updated at a time.
@@ -122,7 +122,7 @@ int __system_property_del(const char *name);
 int __system_property_update2(prop_info *pi, const char *value, unsigned int len);
 
 /* Read the serial number of a system property returned by
-** __system_property_find2.
+** __system_property_find.
 **
 ** Returns the serial number on success, -1 on error.
 */
@@ -136,7 +136,7 @@ uint32_t __system_property_serial2(const prop_info* pi);
  */
 int __system_properties_init2();
 
-/* Deprecated: use __system_property_wait2 instead. */
+/* Deprecated: use __system_property_wait instead. */
 uint32_t __system_property_wait_any2(uint32_t old_serial);
 
 __END_DECLS

jni/resetprop/bionic_macros.h

@@ -17,6 +17,8 @@
 #ifndef _BIONIC_MACROS_H_
 #define _BIONIC_MACROS_H_
 
+#include <stdint.h>
+
 // Frameworks OpenGL code currently leaks this header and allows
 // collisions with other declarations, e.g., from libnativehelper.
 // TODO: Remove once cleaned up. b/18334516
@@ -46,4 +48,22 @@
     ? (1UL << (64 - __builtin_clzl(static_cast<unsigned long>(value)))) \
     : (1UL << (32 - __builtin_clz(static_cast<unsigned int>(value)))))
 
+static constexpr uintptr_t align_down(uintptr_t p, size_t align) {
+  return p & ~(align - 1);
+}
+
+static constexpr uintptr_t align_up(uintptr_t p, size_t align) {
+  return (p + align - 1) & ~(align - 1);
+}
+
+template <typename T>
+static inline T* align_down(T* p, size_t align) {
+  return reinterpret_cast<T*>(align_down(reinterpret_cast<uintptr_t>(p), align));
+}
+
+template <typename T>
+static inline T* align_up(T* p, size_t align) {
+  return reinterpret_cast<T*>(align_up(reinterpret_cast<uintptr_t>(p), align));
+}
+
 #endif // _BIONIC_MACROS_H_

jni/resetprop/resetprop.cpp

@@ -1,10 +1,10 @@
 /* resetprop.cpp - Manipulate any system props
- * 
+ *
  * Copyright 2016 nkk71     <nkk71x@gmail.com>
  * Copyright 2016 topjohnwu <topjohnwu@gmail.com>
- * 
+ *
  * Info:
- * 
+ *
  * all changes are in
  *
  * bionic/libc/bionic/system_properties.cpp
@@ -26,23 +26,23 @@
  *
  * static prop_area* map_fd_ro(const int fd)
  *     we dont want this read only so change: 'PROT_READ' to 'PROT_READ | PROT_WRITE'
- * 
+ *
  *
  * Copy the code of prop_info *prop_area::find_property, and modify to delete props
  * const prop_info *prop_area::find_property_and_del(prop_bt *const trie, const char *name)
  * {
- *    ... 
+ *    ...
  *    ...  Do not alloc a new prop_bt here, remove all code involve alloc_if_needed
  *    ...
- * 
+ *
  *     if (prop_offset != 0) {
  *         atomic_store_explicit(&current->prop, 0, memory_order_release); // Add this line to nullify the prop entry
  *         return to_prop_info(&current->prop);
  *     } else {
- *     
+ *
  *    ....
  * }
- *      
+ *
  *
  * by patching just those functions directly, all other functions should be ok
  * as is.
@@ -56,236 +56,352 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
+#include <dirent.h>
 #include <sys/types.h>
 
 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
 #include "_system_properties.h"
-#include <sys/system_properties.h>
+#include "system_properties.h"
 
-#ifdef INDEP_BINARY
-
-int resetprop_main(int argc, char *argv[]);
-int main(int argc, char *argv[]) {
-    return resetprop_main(argc, argv);
-}
-#define PRINT_D(...)  if (verbose) printf(__VA_ARGS__)
-#define PRINT_E(...)  fprintf(stderr, __VA_ARGS__)
-
-#else
 #include "magisk.h"
-
-#define PRINT_D(...)  { LOGD(__VA_ARGS__); if (verbose) printf(__VA_ARGS__); }
-#define PRINT_E(...)  { LOGE(__VA_ARGS__); fprintf(stderr, __VA_ARGS__); }
-
-#endif
-
 #include "resetprop.h"
+extern "C" {
+#include "vector.h"
+}
+
+#define PRINT_D(...)  { LOGD(__VA_ARGS__); if (verbose) fprintf(stderr, __VA_ARGS__); }
+#define PRINT_E(...)  { LOGE(__VA_ARGS__); fprintf(stderr, __VA_ARGS__); }
+#define PERSISTENT_PROPERTY_DIR  "/data/property"
 
 static int verbose = 0;
 
-static bool is_legal_property_name(const char* name, size_t namelen) {
-    if (namelen < 1) return false;
-    if (name[0] == '.') return false;
-    if (name[namelen - 1] == '.') return false;
+static int check_legal_property_name(const char *name) {
+	int namelen = strlen(name);
 
-    /* Only allow alphanumeric, plus '.', '-', or '_' */
-    /* Don't allow ".." to appear in a property name */
-    for (size_t i = 0; i < namelen; i++) {
-        if (name[i] == '.') {
-            // i=0 is guaranteed to never have a dot. See above.
-            if (name[i - 1] == '.') return false;
-            continue;
-        }
-        if (name[i] == '_' || name[i] == '-') continue;
-        if (name[i] >= 'a' && name[i] <= 'z') continue;
-        if (name[i] >= 'A' && name[i] <= 'Z') continue;
-        if (name[i] >= '0' && name[i] <= '9') continue;
-        return false;
-    }
+	if (namelen < 1) goto illegal;
+	if (name[0] == '.') goto illegal;
+	if (name[namelen - 1] == '.') goto illegal;
 
-    return true;
+	/* Only allow alphanumeric, plus '.', '-', '@', ':', or '_' */
+	/* Don't allow ".." to appear in a property name */
+	for (size_t i = 0; i < namelen; i++) {
+		if (name[i] == '.') {
+			// i=0 is guaranteed to never have a dot. See above.
+			if (name[i-1] == '.') goto illegal;
+			continue;
+		}
+		if (name[i] == '_' || name[i] == '-' || name[i] == '@' || name[i] == ':') continue;
+		if (name[i] >= 'a' && name[i] <= 'z') continue;
+		if (name[i] >= 'A' && name[i] <= 'Z') continue;
+		if (name[i] >= '0' && name[i] <= '9') continue;
+		goto illegal;
+	}
+
+	return 0;
+
+illegal:
+	PRINT_E("Illegal property name: [%s]\n", name);
+	return 1;
 }
 
 static int usage(char* arg0) {
-    fprintf(stderr,
-        "resetprop v" xstr(MAGISK_VERSION) " (by topjohnwu & nkk71) - System Props Modification Tool\n\n"
-        "Usage: %s [options] [args...]\n"
-        "%s <name> <value>:      Set property entry <name> with <value>\n"
-        "%s --file <prop file>:  Load props from <prop file>\n"
-        "%s --delete <name>:     Remove prop entry <name>\n"
-        "\n"
-        "Options:\n"
-        "   -v          verbose output\n"
-        "   -n          don't trigger events when changing props\n"
-    , arg0, arg0, arg0, arg0);
-    return 1;
+	fprintf(stderr,
+		"resetprop v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") (by topjohnwu & nkk71) - System Props Modification Tool\n\n"
+		"Usage: %s [flags] [options...]\n"
+		"\n"
+		"Options:\n"
+		"   -h, --help        show this message\n"
+		"   (no arguments)    print all properties\n"
+		"   NAME              get property\n"
+		"   NAME VALUE        set property entry NAME with VALUE\n"
+		"   --file FILE       load props from FILE\n"
+		"   --delete NAME     delete property\n"
+		"\n"
+		"Flags:\n"
+		"   -v      print verbose output to stderr\n"
+		"   -n      set properties without init triggers\n"
+		"           only affects setprop\n"
+		"   -p      access actual persist storage\n"
+		"           only affects getprop and deleteprop\n"
+		"\n"
+
+	, arg0);
+	return 1;
 }
 
-int init_resetprop() {
-    PRINT_D("resetprop: Initializing...\n");
-    if (__system_properties_init2()) {
-        PRINT_E("resetprop: Initialize error\n");
-        return -1;
-    }
-    return 0;
+static int init_resetprop() {
+	if (__system_properties_init2()) {
+		PRINT_E("resetprop: Initialize error\n");
+		return -1;
+	}
+	return 0;
+}
+
+int prop_exist(const char *name) {
+	if (init_resetprop()) return 0;
+	return __system_property_find2(name) != NULL;
 }
 
 static void read_prop_info(void* cookie, const char *name, const char *value, uint32_t serial) {
-    strcpy((char *) cookie, value);
+	strcpy((char *) cookie, value);
+}
+
+
+char *getprop(const char *name) {
+	return getprop2(name, 0);
 }
 
 // Get prop by name, return string (should free manually!)
-char *getprop(const char *name) {
-    const prop_info *pi = __system_property_find2(name);
-    if (pi == NULL) {
-        PRINT_D("resetprop: failed to get [%s]\n", name);
-        return NULL;
-    }
-    char value[PROP_VALUE_MAX];
-    __system_property_read_callback2(pi, read_prop_info, value);
-    PRINT_D("resetprop: getprop [%s]: [%s]\n", name, value);
-    return strdup(value);
+char *getprop2(const char *name, int persist) {
+	if (check_legal_property_name(name))
+		return NULL;
+	char value[PROP_VALUE_MAX];
+	if (init_resetprop()) return NULL;
+	const prop_info *pi = __system_property_find2(name);
+	if (pi == NULL) {
+		if (persist && strncmp(name, "persist.", 8) == 0) {
+			// Try to read from file
+			char path[PATH_MAX];
+			snprintf(path, sizeof(path), PERSISTENT_PROPERTY_DIR "/%s", name);
+			int fd = open(path, O_RDONLY | O_CLOEXEC);
+			if (fd < 0) goto no_prop;
+			PRINT_D("resetprop: read prop from [%s]\n", path);
+			size_t len = read(fd, value, sizeof(value));
+			value[len] = '\0';  // Null terminate the read value
+		} else {
+no_prop:
+		PRINT_D("resetprop: prop [%s] does not exist\n", name);
+		return NULL;
+		}
+	} else {
+		__system_property_read_callback2(pi, read_prop_info, value);
+	}
+	PRINT_D("resetprop: getprop [%s]: [%s]\n", name, value);
+	return strdup(value);
+}
+
+struct wrapper {
+	void (*func)(const char *, const char *);
+};
+
+static void cb_wrapper(void* cookie, const char *name, const char *value, uint32_t serial) {
+	((wrapper *) cookie)->func(name, value);
+}
+
+static void prop_foreach_cb(const prop_info* pi, void* cookie) {
+	__system_property_read_callback2(pi, cb_wrapper, cookie);
+}
+
+class property {
+public:
+	property(const char *n, const char *v) {
+		name = strdup(n);
+		value = strdup(v);
+	}
+	~property() {
+		free((void *)name);
+		free((void *)value);
+	}
+	const char *name;
+	const char *value;
+};
+
+vector prop_list;
+
+static int prop_cmp(const void *p1, const void *p2) {
+	return strcmp((*((property **) p1))->name, (*((property **) p2))->name);
+}
+
+static void print_all_props_cb(const char *name, const char *value) {
+	vec_push_back(&prop_list, new property(name, value));
+}
+
+static void print_all_props(int persist) {
+	void *p;
+	vec_init(&prop_list);
+	getprop_all(print_all_props_cb);
+	if (persist) {
+		// Check all persist props in data
+		DIR *dir = opendir(PERSISTENT_PROPERTY_DIR);
+		struct dirent *entry;
+		while ((entry = readdir(dir))) {
+			if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0 )
+				continue;
+			int found = 0;
+			vec_for_each(&prop_list, p) {
+				if (strcmp(((property *) p)->name, entry->d_name) == 0) {
+					found = 1;
+					break;
+				}
+			}
+			if (!found)
+				vec_push_back(&prop_list, new property(entry->d_name, getprop2(entry->d_name, 1)));
+		}
+	}
+	vec_sort(&prop_list, prop_cmp);
+	vec_for_each(&prop_list, p) {
+		printf("[%s]: [%s]\n", ((property *) p)->name, ((property *) p)->value);
+		delete((property *) p);
+	}
+	vec_destroy(&prop_list);
+}
+
+void getprop_all(void (*callback)(const char*, const char*)) {
+	if (init_resetprop()) return;
+	struct wrapper wrap = {
+		.func = callback
+	};
+	__system_property_foreach2(prop_foreach_cb, &wrap);
 }
 
 int setprop(const char *name, const char *value) {
-    return setprop2(name, value, 1);
+	return setprop2(name, value, 1);
 }
 
 int setprop2(const char *name, const char *value, const int trigger) {
-    int ret;
-    
-    char *check = getprop(name);
-    if (check) {
-        free(check);
-        if (trigger) {
-            if (!strncmp(name, "ro.", 3)) deleteprop(name);
-            ret = __system_property_set2(name, value);
-        } else {
-            ret = __system_property_update2((prop_info*) __system_property_find2(name), value, strlen(value));
-        }
-    } else {
-        PRINT_D("resetprop: New prop [%s]\n", name);
-        if (trigger) {
-            ret = __system_property_set2(name, value);
-        } else {
-            ret = __system_property_add2(name, strlen(name), value, strlen(value));
-        }
-    }
+	if (check_legal_property_name(name))
+		return 1;
+	if (init_resetprop()) return -1;
+	int ret;
 
-    PRINT_D("resetprop: setprop [%s]: [%s] by %s\n", name, value,
-        trigger ? "property_service" : "modifing prop data structure");
+	prop_info *pi = (prop_info*) __system_property_find2(name);
+	if (pi != NULL) {
+		if (trigger) {
+			if (strncmp(name, "ro.", 3) == 0) deleteprop(name);
+			ret = __system_property_set2(name, value);
+		} else {
+			ret = __system_property_update2(pi, value, strlen(value));
+		}
+	} else {
+		PRINT_D("resetprop: New prop [%s]\n", name);
+		if (trigger) {
+			ret = __system_property_set2(name, value);
+		} else {
+			ret = __system_property_add2(name, strlen(name), value, strlen(value));
+		}
+	}
 
-    if (ret)
-        PRINT_E("resetprop: setprop error\n");
+	PRINT_D("resetprop: setprop [%s]: [%s] by %s\n", name, value,
+		trigger ? "property_service" : "modifing prop data structure");
 
-    return ret;
+	if (ret)
+		PRINT_E("resetprop: setprop error\n");
+
+	return ret;
 }
 
 int deleteprop(const char *name) {
-    PRINT_D("resetprop: deleteprop [%s]\n", name);
-    if (__system_property_del(name)) {
-        PRINT_E("resetprop: delete prop: [%s] error\n", name);
-        return -1;
-    }
-    return 0;
+	return deleteprop2(name, 1);
+}
+
+int deleteprop2(const char *name, const int persist) {
+	if (check_legal_property_name(name))
+		return 1;
+	if (init_resetprop()) return -1;
+	char path[PATH_MAX];
+	path[0] = '\0';
+	PRINT_D("resetprop: deleteprop [%s]\n", name);
+	if (persist && strncmp(name, "persist.", 8) == 0)
+		snprintf(path, sizeof(path), PERSISTENT_PROPERTY_DIR "/%s", name);
+	return __system_property_del(name) && unlink(path);
 }
 
 int read_prop_file(const char* filename, const int trigger) {
-    PRINT_D("resetprop: Load prop file [%s]\n", filename);
-    FILE *fp = fopen(filename, "r");
-    if (fp == NULL) {
-        PRINT_E("Cannot open [%s]\n", filename);
-        return 1;
-    }
-    char *line = NULL, *pch;
-    size_t len;
-    ssize_t read;
-    int comment = 0, i;
-    while ((read = getline(&line, &len, fp)) != -1) {
-        // Remove the trailing newline
-        if (line[read - 1] == '\n') {
-            line[read - 1] = '\0';
-            --read;
-        }
-        comment = 0;
-        for (i = 0; i < read; ++i) {
-            // Ignore starting spaces
-            if (line[i] == ' ') continue;
-            else {
-                // A line starting with # is ignored
-                if (line[i] == '#') comment = 1;
-                break;
-            }
-        }
-        if (comment) continue;
-        pch = strchr(line, '=');
-        // Ignore ivalid formats
-        if ( ((pch == NULL) || (i >= (pch - line))) || (pch >= line + read - 1) ) continue;
-        // Separate the string
-        *pch = '\0';
-        setprop2(line + i, pch + 1, trigger);
-    }
-    free(line);
-    fclose(fp);
-    return 0;
+	if (init_resetprop()) return -1;
+	PRINT_D("resetprop: Load prop file [%s]\n", filename);
+	FILE *fp = fopen(filename, "r");
+	if (fp == NULL) {
+		PRINT_E("Cannot open [%s]\n", filename);
+		return 1;
+	}
+	char *line = NULL, *pch;
+	size_t len;
+	ssize_t read;
+	int comment = 0, i;
+	while ((read = getline(&line, &len, fp)) != -1) {
+		// Remove the trailing newline
+		if (line[read - 1] == '\n') {
+			line[read - 1] = '\0';
+			--read;
+		}
+		comment = 0;
+		for (i = 0; i < read; ++i) {
+			// Ignore starting spaces
+			if (line[i] == ' ') continue;
+			else {
+				// A line starting with # is ignored
+				if (line[i] == '#') comment = 1;
+				break;
+			}
+		}
+		if (comment) continue;
+		pch = strchr(line, '=');
+		// Ignore ivalid formats
+		if ( ((pch == NULL) || (i >= (pch - line))) || (pch >= line + read - 1) ) continue;
+		// Separate the string
+		*pch = '\0';
+		setprop2(line + i, pch + 1, trigger);
+	}
+	free(line);
+	fclose(fp);
+	return 0;
 }
 
 int resetprop_main(int argc, char *argv[]) {
+	int trigger = 1, persist = 0;
+	char *argv0 = argv[0], *prop;
 
-    int del = 0, file = 0, trigger = 1;
-    
-    int exp_arg = 2;
-    char *name, *value, *filename;
+	--argc;
+	++argv;
 
-    if (argc < 3) {
-        return usage(argv[0]);
-    }
+	// Parse flags and -- options
+	while (argc && argv[0][0] == '-') {
+		for (int idx = 1; 1; ++idx) {
+			switch (argv[0][idx]) {
+			case '-':
+				if (strcmp(argv[0], "--file") == 0 && argc == 2) {
+					return read_prop_file(argv[1], trigger);
+				} else if (strcmp(argv[0], "--delete") == 0 && argc == 2) {
+					return deleteprop2(argv[1], persist);
+				} else if (strcmp(argv[0], "--help") == 0) {
+					goto usage;
+				}
+			case 'v':
+				verbose = 1;
+				continue;
+			case 'p':
+				persist = 1;
+				continue;
+			case 'n':
+				trigger = 0;
+				continue;
+			case '\0':
+				break;
+			case 'h':
+			default:
+			usage:
+				return usage(argv0);
+			}
+			break;
+		}
+		--argc;
+		++argv;
+	}
 
-    for (int i = 1; i < argc; ++i) {
-        if (!strcmp("-v", argv[i])) {
-            verbose = 1;
-        } else if (!strcmp("-n", argv[i])) {
-            trigger = 0;
-        } else if (!strcmp("--file", argv[i])) {
-            file = 1;
-            exp_arg = 1;
-        } else if (!strcmp("--delete", argv[i])) {
-            del = 1;
-            exp_arg = 1;
-        } else {
-            if (i + exp_arg > argc) {
-                return usage(argv[0]);
-            }
-            if (file) {
-                filename = argv[i];
-                break;
-            } else {
-                if(!is_legal_property_name(argv[i], strlen(argv[i]))) {
-                    PRINT_E("Illegal property name: [%s]\n", argv[i]);
-                    return 1;
-                }
-                name = argv[i];
-                if (exp_arg > 1) {
-                    if (strlen(argv[i + 1]) >= PROP_VALUE_MAX) {
-                        PRINT_E("Value too long: [%s]\n", argv[i + 1]);
-                        return 1;
-                    }
-                    value = argv[i + 1];
-                }
-                break;
-            }
-        }
-    }
-
-    init_resetprop();
-
-    if (file) {
-        return read_prop_file(filename, trigger);
-    } else if (del) {
-        return deleteprop(name);
-    } else {
-        return setprop2(name, value, trigger);
-    }
-
-    return 0;
+	switch (argc) {
+	case 0:
+		print_all_props(persist);
+		return 0;
+	case 1:
+		prop = getprop2(argv[0], persist);
+		if (prop == NULL) return 1;
+		printf("%s\n", prop);
+		free(prop);
+		return 0;
+	case 2:
+		return setprop2(argv[0], argv[1], trigger);
+	default:
+		usage(argv0);
+		return 1;
+	}
 }

jni/resetprop/system_properties.cpp

@@ -30,11 +30,13 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
+#include <stdio.h>
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <stdarg.h>
 #include <string.h>
 #include <unistd.h>
 #include <new>
@@ -48,6 +50,9 @@
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/un.h>
+
+#undef XATTR_CREATE
+#undef XATTR_REPLACE
 #include <sys/xattr.h>
 
 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
@@ -1149,9 +1154,7 @@ int __system_properties_init2() {
 
   if (initialized) {
     // list_foreach(contexts, [](context_node* l) { l->reset_access(); });    // resetprop remove
-    // return 0;                                                              // resetprop remove
-    free_and_unmap_contexts();                                                // resetprop add
-    initialized = false;                                                      // resetprop add
+    return 0;
   }
   if (is_dir(property_filename)) {
     if (!initialize_properties()) {
@@ -1207,7 +1210,7 @@ uint32_t __system_property_area_serial2() {
   if (!pa) {
     return -1;
   }
-  // Make sure this read fulfilled before __system_property_serial2
+  // Make sure this read fulfilled before __system_property_serial
   return atomic_load_explicit(pa->serial(), memory_order_acquire);
 }
 
@@ -1298,7 +1301,7 @@ void __system_property_read_callback2(const prop_info* pi,
     memcpy(value_buf, pi->value, len);
     value_buf[len] = '\0';
 
-    // TODO: see todo in __system_property_read2 function
+    // TODO: see todo in __system_property_read function
     atomic_thread_fence(memory_order_acquire);
     if (serial == load_const_atomic(&(pi->serial), memory_order_relaxed)) {
       callback(cookie, pi->name, value_buf, serial);
@@ -1321,7 +1324,7 @@ int __system_property_get2(const char* name, char* value) {
 static constexpr uint32_t kProtocolVersion1 = 1;
 static constexpr uint32_t kProtocolVersion2 = 2;  // current
 
-static atomic_uint_least32_t g_propservice_protocol_version = 0;
+static uint32_t g_propservice_protocol_version = 0;
 
 static void detect_protocol_version() {
   char value[PROP_VALUE_MAX];
@@ -1488,7 +1491,7 @@ int __system_property_add2(const char* name, unsigned int namelen, const char* v
 uint32_t __system_property_serial2(const prop_info* pi) {
   uint32_t serial = load_const_atomic(&pi->serial, memory_order_acquire);
   while (SERIAL_DIRTY(serial)) {
-    __futex_wait(const_cast<_Atomic(uint_least32_t)*>(&pi->serial), serial, nullptr);
+    __futex_wait(const_cast<atomic_uint_least32_t*>(&pi->serial), serial, nullptr);
     serial = load_const_atomic(&pi->serial, memory_order_acquire);
   }
   return serial;

jni/resetprop/system_properties.h

@@ -43,11 +43,11 @@ typedef struct prop_info prop_info;
 /*
  * Sets system property `key` to `value`, creating the system property if it doesn't already exist.
  */
-int __system_property_set2(const char* key, const char* value) __INTRODUCED_IN(12);
+int __system_property_set2(const char* key, const char* value);
 
 /*
  * Returns a `prop_info` corresponding system property `name`, or nullptr if it doesn't exist.
- * Use __system_property_read_callback2 to query the current value.
+ * Use __system_property_read_callback to query the current value.
  *
  * Property lookup is expensive, so it can be useful to cache the result of this function.
  */
@@ -58,16 +58,15 @@ const prop_info* __system_property_find2(const char* name);
  */
 void __system_property_read_callback2(const prop_info *pi,
     void (*callback)(void* cookie, const char *name, const char *value, uint32_t serial),
-    void* cookie) __INTRODUCED_IN(26);
+    void* cookie);
 
 /*
  * Passes a `prop_info` for each system property to the provided
- * callback.  Use __system_property_read_callback2() to read the value.
+ * callback.  Use __system_property_read_callback() to read the value.
  *
  * This method is for inspecting and debugging the property system, and not generally useful.
  */
-int __system_property_foreach2(void (*propfn)(const prop_info* pi, void* cookie), void* cookie)
-  __INTRODUCED_IN(19);
+int __system_property_foreach2(void (*propfn)(const prop_info* pi, void* cookie), void* cookie);
 
 /*
  * Waits for the specific system property identified by `pi` to be updated
@@ -85,16 +84,15 @@ struct timespec;
 bool __system_property_wait2(const prop_info* pi,
                             uint32_t old_serial,
                             uint32_t* new_serial_ptr,
-                            const struct timespec* relative_timeout)
-    __INTRODUCED_IN(26);
+                            const struct timespec* relative_timeout);
 
 /* Deprecated. In Android O and above, there's no limit on property name length. */
 #define PROP_NAME_MAX   32
-/* Deprecated. Use __system_property_read_callback2 instead. */
+/* Deprecated. Use __system_property_read_callback instead. */
 int __system_property_read2(const prop_info* pi, char* name, char* value);
-/* Deprecated. Use __system_property_read_callback2 instead. */
+/* Deprecated. Use __system_property_read_callback instead. */
 int __system_property_get2(const char* name, char* value);
-/* Deprecated. Use __system_property_foreach2 instead. */
+/* Deprecated. Use __system_property_foreach instead. */
 const prop_info* __system_property_find_nth2(unsigned n);
 
 __END_DECLS

jni/sqlite3/Android.mk

@@ -1,10 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-
-##
-# libsqlite.so
-#
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:= libsqlite
-LOCAL_SRC_FILES := sqlite3.c shell.c
-include $(BUILD_SHARED_LIBRARY)

jni/sqlite3/sqlite3ext.h

@@ -1,564 +0,0 @@
-/*
-** 2006 June 7
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-** This header file defines the SQLite interface for use by
-** shared libraries that want to be imported as extensions into
-** an SQLite instance.  Shared libraries that intend to be loaded
-** as extensions by SQLite should #include this file instead of 
-** sqlite3.h.
-*/
-#ifndef SQLITE3EXT_H
-#define SQLITE3EXT_H
-#include "sqlite3.h"
-
-/*
-** The following structure holds pointers to all of the SQLite API
-** routines.
-**
-** WARNING:  In order to maintain backwards compatibility, add new
-** interfaces to the end of this structure only.  If you insert new
-** interfaces in the middle of this structure, then older different
-** versions of SQLite will not be able to load each other's shared
-** libraries!
-*/
-struct sqlite3_api_routines {
-  void * (*aggregate_context)(sqlite3_context*,int nBytes);
-  int  (*aggregate_count)(sqlite3_context*);
-  int  (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
-  int  (*bind_double)(sqlite3_stmt*,int,double);
-  int  (*bind_int)(sqlite3_stmt*,int,int);
-  int  (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
-  int  (*bind_null)(sqlite3_stmt*,int);
-  int  (*bind_parameter_count)(sqlite3_stmt*);
-  int  (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
-  const char * (*bind_parameter_name)(sqlite3_stmt*,int);
-  int  (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
-  int  (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
-  int  (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
-  int  (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
-  int  (*busy_timeout)(sqlite3*,int ms);
-  int  (*changes)(sqlite3*);
-  int  (*close)(sqlite3*);
-  int  (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
-                           int eTextRep,const char*));
-  int  (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
-                             int eTextRep,const void*));
-  const void * (*column_blob)(sqlite3_stmt*,int iCol);
-  int  (*column_bytes)(sqlite3_stmt*,int iCol);
-  int  (*column_bytes16)(sqlite3_stmt*,int iCol);
-  int  (*column_count)(sqlite3_stmt*pStmt);
-  const char * (*column_database_name)(sqlite3_stmt*,int);
-  const void * (*column_database_name16)(sqlite3_stmt*,int);
-  const char * (*column_decltype)(sqlite3_stmt*,int i);
-  const void * (*column_decltype16)(sqlite3_stmt*,int);
-  double  (*column_double)(sqlite3_stmt*,int iCol);
-  int  (*column_int)(sqlite3_stmt*,int iCol);
-  sqlite_int64  (*column_int64)(sqlite3_stmt*,int iCol);
-  const char * (*column_name)(sqlite3_stmt*,int);
-  const void * (*column_name16)(sqlite3_stmt*,int);
-  const char * (*column_origin_name)(sqlite3_stmt*,int);
-  const void * (*column_origin_name16)(sqlite3_stmt*,int);
-  const char * (*column_table_name)(sqlite3_stmt*,int);
-  const void * (*column_table_name16)(sqlite3_stmt*,int);
-  const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
-  const void * (*column_text16)(sqlite3_stmt*,int iCol);
-  int  (*column_type)(sqlite3_stmt*,int iCol);
-  sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
-  void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
-  int  (*complete)(const char*sql);
-  int  (*complete16)(const void*sql);
-  int  (*create_collation)(sqlite3*,const char*,int,void*,
-                           int(*)(void*,int,const void*,int,const void*));
-  int  (*create_collation16)(sqlite3*,const void*,int,void*,
-                             int(*)(void*,int,const void*,int,const void*));
-  int  (*create_function)(sqlite3*,const char*,int,int,void*,
-                          void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                          void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                          void (*xFinal)(sqlite3_context*));
-  int  (*create_function16)(sqlite3*,const void*,int,int,void*,
-                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*));
-  int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
-  int  (*data_count)(sqlite3_stmt*pStmt);
-  sqlite3 * (*db_handle)(sqlite3_stmt*);
-  int (*declare_vtab)(sqlite3*,const char*);
-  int  (*enable_shared_cache)(int);
-  int  (*errcode)(sqlite3*db);
-  const char * (*errmsg)(sqlite3*);
-  const void * (*errmsg16)(sqlite3*);
-  int  (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
-  int  (*expired)(sqlite3_stmt*);
-  int  (*finalize)(sqlite3_stmt*pStmt);
-  void  (*free)(void*);
-  void  (*free_table)(char**result);
-  int  (*get_autocommit)(sqlite3*);
-  void * (*get_auxdata)(sqlite3_context*,int);
-  int  (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
-  int  (*global_recover)(void);
-  void  (*interruptx)(sqlite3*);
-  sqlite_int64  (*last_insert_rowid)(sqlite3*);
-  const char * (*libversion)(void);
-  int  (*libversion_number)(void);
-  void *(*malloc)(int);
-  char * (*mprintf)(const char*,...);
-  int  (*open)(const char*,sqlite3**);
-  int  (*open16)(const void*,sqlite3**);
-  int  (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
-  int  (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
-  void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
-  void  (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
-  void *(*realloc)(void*,int);
-  int  (*reset)(sqlite3_stmt*pStmt);
-  void  (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_double)(sqlite3_context*,double);
-  void  (*result_error)(sqlite3_context*,const char*,int);
-  void  (*result_error16)(sqlite3_context*,const void*,int);
-  void  (*result_int)(sqlite3_context*,int);
-  void  (*result_int64)(sqlite3_context*,sqlite_int64);
-  void  (*result_null)(sqlite3_context*);
-  void  (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
-  void  (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
-  void  (*result_value)(sqlite3_context*,sqlite3_value*);
-  void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
-  int  (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
-                         const char*,const char*),void*);
-  void  (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
-  char * (*snprintf)(int,char*,const char*,...);
-  int  (*step)(sqlite3_stmt*);
-  int  (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
-                                char const**,char const**,int*,int*,int*);
-  void  (*thread_cleanup)(void);
-  int  (*total_changes)(sqlite3*);
-  void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
-  int  (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
-  void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
-                                         sqlite_int64),void*);
-  void * (*user_data)(sqlite3_context*);
-  const void * (*value_blob)(sqlite3_value*);
-  int  (*value_bytes)(sqlite3_value*);
-  int  (*value_bytes16)(sqlite3_value*);
-  double  (*value_double)(sqlite3_value*);
-  int  (*value_int)(sqlite3_value*);
-  sqlite_int64  (*value_int64)(sqlite3_value*);
-  int  (*value_numeric_type)(sqlite3_value*);
-  const unsigned char * (*value_text)(sqlite3_value*);
-  const void * (*value_text16)(sqlite3_value*);
-  const void * (*value_text16be)(sqlite3_value*);
-  const void * (*value_text16le)(sqlite3_value*);
-  int  (*value_type)(sqlite3_value*);
-  char *(*vmprintf)(const char*,va_list);
-  /* Added ??? */
-  int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
-  /* Added by 3.3.13 */
-  int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
-  int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
-  int (*clear_bindings)(sqlite3_stmt*);
-  /* Added by 3.4.1 */
-  int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
-                          void (*xDestroy)(void *));
-  /* Added by 3.5.0 */
-  int (*bind_zeroblob)(sqlite3_stmt*,int,int);
-  int (*blob_bytes)(sqlite3_blob*);
-  int (*blob_close)(sqlite3_blob*);
-  int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
-                   int,sqlite3_blob**);
-  int (*blob_read)(sqlite3_blob*,void*,int,int);
-  int (*blob_write)(sqlite3_blob*,const void*,int,int);
-  int (*create_collation_v2)(sqlite3*,const char*,int,void*,
-                             int(*)(void*,int,const void*,int,const void*),
-                             void(*)(void*));
-  int (*file_control)(sqlite3*,const char*,int,void*);
-  sqlite3_int64 (*memory_highwater)(int);
-  sqlite3_int64 (*memory_used)(void);
-  sqlite3_mutex *(*mutex_alloc)(int);
-  void (*mutex_enter)(sqlite3_mutex*);
-  void (*mutex_free)(sqlite3_mutex*);
-  void (*mutex_leave)(sqlite3_mutex*);
-  int (*mutex_try)(sqlite3_mutex*);
-  int (*open_v2)(const char*,sqlite3**,int,const char*);
-  int (*release_memory)(int);
-  void (*result_error_nomem)(sqlite3_context*);
-  void (*result_error_toobig)(sqlite3_context*);
-  int (*sleep)(int);
-  void (*soft_heap_limit)(int);
-  sqlite3_vfs *(*vfs_find)(const char*);
-  int (*vfs_register)(sqlite3_vfs*,int);
-  int (*vfs_unregister)(sqlite3_vfs*);
-  int (*xthreadsafe)(void);
-  void (*result_zeroblob)(sqlite3_context*,int);
-  void (*result_error_code)(sqlite3_context*,int);
-  int (*test_control)(int, ...);
-  void (*randomness)(int,void*);
-  sqlite3 *(*context_db_handle)(sqlite3_context*);
-  int (*extended_result_codes)(sqlite3*,int);
-  int (*limit)(sqlite3*,int,int);
-  sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
-  const char *(*sql)(sqlite3_stmt*);
-  int (*status)(int,int*,int*,int);
-  int (*backup_finish)(sqlite3_backup*);
-  sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
-  int (*backup_pagecount)(sqlite3_backup*);
-  int (*backup_remaining)(sqlite3_backup*);
-  int (*backup_step)(sqlite3_backup*,int);
-  const char *(*compileoption_get)(int);
-  int (*compileoption_used)(const char*);
-  int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
-                            void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*),
-                            void(*xDestroy)(void*));
-  int (*db_config)(sqlite3*,int,...);
-  sqlite3_mutex *(*db_mutex)(sqlite3*);
-  int (*db_status)(sqlite3*,int,int*,int*,int);
-  int (*extended_errcode)(sqlite3*);
-  void (*log)(int,const char*,...);
-  sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
-  const char *(*sourceid)(void);
-  int (*stmt_status)(sqlite3_stmt*,int,int);
-  int (*strnicmp)(const char*,const char*,int);
-  int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
-  int (*wal_autocheckpoint)(sqlite3*,int);
-  int (*wal_checkpoint)(sqlite3*,const char*);
-  void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
-  int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
-  int (*vtab_config)(sqlite3*,int op,...);
-  int (*vtab_on_conflict)(sqlite3*);
-  /* Version 3.7.16 and later */
-  int (*close_v2)(sqlite3*);
-  const char *(*db_filename)(sqlite3*,const char*);
-  int (*db_readonly)(sqlite3*,const char*);
-  int (*db_release_memory)(sqlite3*);
-  const char *(*errstr)(int);
-  int (*stmt_busy)(sqlite3_stmt*);
-  int (*stmt_readonly)(sqlite3_stmt*);
-  int (*stricmp)(const char*,const char*);
-  int (*uri_boolean)(const char*,const char*,int);
-  sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64);
-  const char *(*uri_parameter)(const char*,const char*);
-  char *(*vsnprintf)(int,char*,const char*,va_list);
-  int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*);
-  /* Version 3.8.7 and later */
-  int (*auto_extension)(void(*)(void));
-  int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64,
-                     void(*)(void*));
-  int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64,
-                      void(*)(void*),unsigned char);
-  int (*cancel_auto_extension)(void(*)(void));
-  int (*load_extension)(sqlite3*,const char*,const char*,char**);
-  void *(*malloc64)(sqlite3_uint64);
-  sqlite3_uint64 (*msize)(void*);
-  void *(*realloc64)(void*,sqlite3_uint64);
-  void (*reset_auto_extension)(void);
-  void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64,
-                        void(*)(void*));
-  void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
-                         void(*)(void*), unsigned char);
-  int (*strglob)(const char*,const char*);
-  /* Version 3.8.11 and later */
-  sqlite3_value *(*value_dup)(const sqlite3_value*);
-  void (*value_free)(sqlite3_value*);
-  int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
-  int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
-  /* Version 3.9.0 and later */
-  unsigned int (*value_subtype)(sqlite3_value*);
-  void (*result_subtype)(sqlite3_context*,unsigned int);
-  /* Version 3.10.0 and later */
-  int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int);
-  int (*strlike)(const char*,const char*,unsigned int);
-  int (*db_cacheflush)(sqlite3*);
-  /* Version 3.12.0 and later */
-  int (*system_errno)(sqlite3*);
-  /* Version 3.14.0 and later */
-  int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*);
-  char *(*expanded_sql)(sqlite3_stmt*);
-  /* Version 3.18.0 and later */
-  void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64);
-};
-
-/*
-** This is the function signature used for all extension entry points.  It
-** is also defined in the file "loadext.c".
-*/
-typedef int (*sqlite3_loadext_entry)(
-  sqlite3 *db,                       /* Handle to the database. */
-  char **pzErrMsg,                   /* Used to set error string on failure. */
-  const sqlite3_api_routines *pThunk /* Extension API function pointers. */
-);
-
-/*
-** The following macros redefine the API routines so that they are
-** redirected through the global sqlite3_api structure.
-**
-** This header file is also used by the loadext.c source file
-** (part of the main SQLite library - not an extension) so that
-** it can get access to the sqlite3_api_routines structure
-** definition.  But the main library does not want to redefine
-** the API.  So the redefinition macros are only valid if the
-** SQLITE_CORE macros is undefined.
-*/
-#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
-#define sqlite3_aggregate_context      sqlite3_api->aggregate_context
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_aggregate_count        sqlite3_api->aggregate_count
-#endif
-#define sqlite3_bind_blob              sqlite3_api->bind_blob
-#define sqlite3_bind_double            sqlite3_api->bind_double
-#define sqlite3_bind_int               sqlite3_api->bind_int
-#define sqlite3_bind_int64             sqlite3_api->bind_int64
-#define sqlite3_bind_null              sqlite3_api->bind_null
-#define sqlite3_bind_parameter_count   sqlite3_api->bind_parameter_count
-#define sqlite3_bind_parameter_index   sqlite3_api->bind_parameter_index
-#define sqlite3_bind_parameter_name    sqlite3_api->bind_parameter_name
-#define sqlite3_bind_text              sqlite3_api->bind_text
-#define sqlite3_bind_text16            sqlite3_api->bind_text16
-#define sqlite3_bind_value             sqlite3_api->bind_value
-#define sqlite3_busy_handler           sqlite3_api->busy_handler
-#define sqlite3_busy_timeout           sqlite3_api->busy_timeout
-#define sqlite3_changes                sqlite3_api->changes
-#define sqlite3_close                  sqlite3_api->close
-#define sqlite3_collation_needed       sqlite3_api->collation_needed
-#define sqlite3_collation_needed16     sqlite3_api->collation_needed16
-#define sqlite3_column_blob            sqlite3_api->column_blob
-#define sqlite3_column_bytes           sqlite3_api->column_bytes
-#define sqlite3_column_bytes16         sqlite3_api->column_bytes16
-#define sqlite3_column_count           sqlite3_api->column_count
-#define sqlite3_column_database_name   sqlite3_api->column_database_name
-#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
-#define sqlite3_column_decltype        sqlite3_api->column_decltype
-#define sqlite3_column_decltype16      sqlite3_api->column_decltype16
-#define sqlite3_column_double          sqlite3_api->column_double
-#define sqlite3_column_int             sqlite3_api->column_int
-#define sqlite3_column_int64           sqlite3_api->column_int64
-#define sqlite3_column_name            sqlite3_api->column_name
-#define sqlite3_column_name16          sqlite3_api->column_name16
-#define sqlite3_column_origin_name     sqlite3_api->column_origin_name
-#define sqlite3_column_origin_name16   sqlite3_api->column_origin_name16
-#define sqlite3_column_table_name      sqlite3_api->column_table_name
-#define sqlite3_column_table_name16    sqlite3_api->column_table_name16
-#define sqlite3_column_text            sqlite3_api->column_text
-#define sqlite3_column_text16          sqlite3_api->column_text16
-#define sqlite3_column_type            sqlite3_api->column_type
-#define sqlite3_column_value           sqlite3_api->column_value
-#define sqlite3_commit_hook            sqlite3_api->commit_hook
-#define sqlite3_complete               sqlite3_api->complete
-#define sqlite3_complete16             sqlite3_api->complete16
-#define sqlite3_create_collation       sqlite3_api->create_collation
-#define sqlite3_create_collation16     sqlite3_api->create_collation16
-#define sqlite3_create_function        sqlite3_api->create_function
-#define sqlite3_create_function16      sqlite3_api->create_function16
-#define sqlite3_create_module          sqlite3_api->create_module
-#define sqlite3_create_module_v2       sqlite3_api->create_module_v2
-#define sqlite3_data_count             sqlite3_api->data_count
-#define sqlite3_db_handle              sqlite3_api->db_handle
-#define sqlite3_declare_vtab           sqlite3_api->declare_vtab
-#define sqlite3_enable_shared_cache    sqlite3_api->enable_shared_cache
-#define sqlite3_errcode                sqlite3_api->errcode
-#define sqlite3_errmsg                 sqlite3_api->errmsg
-#define sqlite3_errmsg16               sqlite3_api->errmsg16
-#define sqlite3_exec                   sqlite3_api->exec
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_expired                sqlite3_api->expired
-#endif
-#define sqlite3_finalize               sqlite3_api->finalize
-#define sqlite3_free                   sqlite3_api->free
-#define sqlite3_free_table             sqlite3_api->free_table
-#define sqlite3_get_autocommit         sqlite3_api->get_autocommit
-#define sqlite3_get_auxdata            sqlite3_api->get_auxdata
-#define sqlite3_get_table              sqlite3_api->get_table
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_global_recover         sqlite3_api->global_recover
-#endif
-#define sqlite3_interrupt              sqlite3_api->interruptx
-#define sqlite3_last_insert_rowid      sqlite3_api->last_insert_rowid
-#define sqlite3_libversion             sqlite3_api->libversion
-#define sqlite3_libversion_number      sqlite3_api->libversion_number
-#define sqlite3_malloc                 sqlite3_api->malloc
-#define sqlite3_mprintf                sqlite3_api->mprintf
-#define sqlite3_open                   sqlite3_api->open
-#define sqlite3_open16                 sqlite3_api->open16
-#define sqlite3_prepare                sqlite3_api->prepare
-#define sqlite3_prepare16              sqlite3_api->prepare16
-#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
-#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
-#define sqlite3_profile                sqlite3_api->profile
-#define sqlite3_progress_handler       sqlite3_api->progress_handler
-#define sqlite3_realloc                sqlite3_api->realloc
-#define sqlite3_reset                  sqlite3_api->reset
-#define sqlite3_result_blob            sqlite3_api->result_blob
-#define sqlite3_result_double          sqlite3_api->result_double
-#define sqlite3_result_error           sqlite3_api->result_error
-#define sqlite3_result_error16         sqlite3_api->result_error16
-#define sqlite3_result_int             sqlite3_api->result_int
-#define sqlite3_result_int64           sqlite3_api->result_int64
-#define sqlite3_result_null            sqlite3_api->result_null
-#define sqlite3_result_text            sqlite3_api->result_text
-#define sqlite3_result_text16          sqlite3_api->result_text16
-#define sqlite3_result_text16be        sqlite3_api->result_text16be
-#define sqlite3_result_text16le        sqlite3_api->result_text16le
-#define sqlite3_result_value           sqlite3_api->result_value
-#define sqlite3_rollback_hook          sqlite3_api->rollback_hook
-#define sqlite3_set_authorizer         sqlite3_api->set_authorizer
-#define sqlite3_set_auxdata            sqlite3_api->set_auxdata
-#define sqlite3_snprintf               sqlite3_api->snprintf
-#define sqlite3_step                   sqlite3_api->step
-#define sqlite3_table_column_metadata  sqlite3_api->table_column_metadata
-#define sqlite3_thread_cleanup         sqlite3_api->thread_cleanup
-#define sqlite3_total_changes          sqlite3_api->total_changes
-#define sqlite3_trace                  sqlite3_api->trace
-#ifndef SQLITE_OMIT_DEPRECATED
-#define sqlite3_transfer_bindings      sqlite3_api->transfer_bindings
-#endif
-#define sqlite3_update_hook            sqlite3_api->update_hook
-#define sqlite3_user_data              sqlite3_api->user_data
-#define sqlite3_value_blob             sqlite3_api->value_blob
-#define sqlite3_value_bytes            sqlite3_api->value_bytes
-#define sqlite3_value_bytes16          sqlite3_api->value_bytes16
-#define sqlite3_value_double           sqlite3_api->value_double
-#define sqlite3_value_int              sqlite3_api->value_int
-#define sqlite3_value_int64            sqlite3_api->value_int64
-#define sqlite3_value_numeric_type     sqlite3_api->value_numeric_type
-#define sqlite3_value_text             sqlite3_api->value_text
-#define sqlite3_value_text16           sqlite3_api->value_text16
-#define sqlite3_value_text16be         sqlite3_api->value_text16be
-#define sqlite3_value_text16le         sqlite3_api->value_text16le
-#define sqlite3_value_type             sqlite3_api->value_type
-#define sqlite3_vmprintf               sqlite3_api->vmprintf
-#define sqlite3_vsnprintf              sqlite3_api->vsnprintf
-#define sqlite3_overload_function      sqlite3_api->overload_function
-#define sqlite3_prepare_v2             sqlite3_api->prepare_v2
-#define sqlite3_prepare16_v2           sqlite3_api->prepare16_v2
-#define sqlite3_clear_bindings         sqlite3_api->clear_bindings
-#define sqlite3_bind_zeroblob          sqlite3_api->bind_zeroblob
-#define sqlite3_blob_bytes             sqlite3_api->blob_bytes
-#define sqlite3_blob_close             sqlite3_api->blob_close
-#define sqlite3_blob_open              sqlite3_api->blob_open
-#define sqlite3_blob_read              sqlite3_api->blob_read
-#define sqlite3_blob_write             sqlite3_api->blob_write
-#define sqlite3_create_collation_v2    sqlite3_api->create_collation_v2
-#define sqlite3_file_control           sqlite3_api->file_control
-#define sqlite3_memory_highwater       sqlite3_api->memory_highwater
-#define sqlite3_memory_used            sqlite3_api->memory_used
-#define sqlite3_mutex_alloc            sqlite3_api->mutex_alloc
-#define sqlite3_mutex_enter            sqlite3_api->mutex_enter
-#define sqlite3_mutex_free             sqlite3_api->mutex_free
-#define sqlite3_mutex_leave            sqlite3_api->mutex_leave
-#define sqlite3_mutex_try              sqlite3_api->mutex_try
-#define sqlite3_open_v2                sqlite3_api->open_v2
-#define sqlite3_release_memory         sqlite3_api->release_memory
-#define sqlite3_result_error_nomem     sqlite3_api->result_error_nomem
-#define sqlite3_result_error_toobig    sqlite3_api->result_error_toobig
-#define sqlite3_sleep                  sqlite3_api->sleep
-#define sqlite3_soft_heap_limit        sqlite3_api->soft_heap_limit
-#define sqlite3_vfs_find               sqlite3_api->vfs_find
-#define sqlite3_vfs_register           sqlite3_api->vfs_register
-#define sqlite3_vfs_unregister         sqlite3_api->vfs_unregister
-#define sqlite3_threadsafe             sqlite3_api->xthreadsafe
-#define sqlite3_result_zeroblob        sqlite3_api->result_zeroblob
-#define sqlite3_result_error_code      sqlite3_api->result_error_code
-#define sqlite3_test_control           sqlite3_api->test_control
-#define sqlite3_randomness             sqlite3_api->randomness
-#define sqlite3_context_db_handle      sqlite3_api->context_db_handle
-#define sqlite3_extended_result_codes  sqlite3_api->extended_result_codes
-#define sqlite3_limit                  sqlite3_api->limit
-#define sqlite3_next_stmt              sqlite3_api->next_stmt
-#define sqlite3_sql                    sqlite3_api->sql
-#define sqlite3_status                 sqlite3_api->status
-#define sqlite3_backup_finish          sqlite3_api->backup_finish
-#define sqlite3_backup_init            sqlite3_api->backup_init
-#define sqlite3_backup_pagecount       sqlite3_api->backup_pagecount
-#define sqlite3_backup_remaining       sqlite3_api->backup_remaining
-#define sqlite3_backup_step            sqlite3_api->backup_step
-#define sqlite3_compileoption_get      sqlite3_api->compileoption_get
-#define sqlite3_compileoption_used     sqlite3_api->compileoption_used
-#define sqlite3_create_function_v2     sqlite3_api->create_function_v2
-#define sqlite3_db_config              sqlite3_api->db_config
-#define sqlite3_db_mutex               sqlite3_api->db_mutex
-#define sqlite3_db_status              sqlite3_api->db_status
-#define sqlite3_extended_errcode       sqlite3_api->extended_errcode
-#define sqlite3_log                    sqlite3_api->log
-#define sqlite3_soft_heap_limit64      sqlite3_api->soft_heap_limit64
-#define sqlite3_sourceid               sqlite3_api->sourceid
-#define sqlite3_stmt_status            sqlite3_api->stmt_status
-#define sqlite3_strnicmp               sqlite3_api->strnicmp
-#define sqlite3_unlock_notify          sqlite3_api->unlock_notify
-#define sqlite3_wal_autocheckpoint     sqlite3_api->wal_autocheckpoint
-#define sqlite3_wal_checkpoint         sqlite3_api->wal_checkpoint
-#define sqlite3_wal_hook               sqlite3_api->wal_hook
-#define sqlite3_blob_reopen            sqlite3_api->blob_reopen
-#define sqlite3_vtab_config            sqlite3_api->vtab_config
-#define sqlite3_vtab_on_conflict       sqlite3_api->vtab_on_conflict
-/* Version 3.7.16 and later */
-#define sqlite3_close_v2               sqlite3_api->close_v2
-#define sqlite3_db_filename            sqlite3_api->db_filename
-#define sqlite3_db_readonly            sqlite3_api->db_readonly
-#define sqlite3_db_release_memory      sqlite3_api->db_release_memory
-#define sqlite3_errstr                 sqlite3_api->errstr
-#define sqlite3_stmt_busy              sqlite3_api->stmt_busy
-#define sqlite3_stmt_readonly          sqlite3_api->stmt_readonly
-#define sqlite3_stricmp                sqlite3_api->stricmp
-#define sqlite3_uri_boolean            sqlite3_api->uri_boolean
-#define sqlite3_uri_int64              sqlite3_api->uri_int64
-#define sqlite3_uri_parameter          sqlite3_api->uri_parameter
-#define sqlite3_uri_vsnprintf          sqlite3_api->vsnprintf
-#define sqlite3_wal_checkpoint_v2      sqlite3_api->wal_checkpoint_v2
-/* Version 3.8.7 and later */
-#define sqlite3_auto_extension         sqlite3_api->auto_extension
-#define sqlite3_bind_blob64            sqlite3_api->bind_blob64
-#define sqlite3_bind_text64            sqlite3_api->bind_text64
-#define sqlite3_cancel_auto_extension  sqlite3_api->cancel_auto_extension
-#define sqlite3_load_extension         sqlite3_api->load_extension
-#define sqlite3_malloc64               sqlite3_api->malloc64
-#define sqlite3_msize                  sqlite3_api->msize
-#define sqlite3_realloc64              sqlite3_api->realloc64
-#define sqlite3_reset_auto_extension   sqlite3_api->reset_auto_extension
-#define sqlite3_result_blob64          sqlite3_api->result_blob64
-#define sqlite3_result_text64          sqlite3_api->result_text64
-#define sqlite3_strglob                sqlite3_api->strglob
-/* Version 3.8.11 and later */
-#define sqlite3_value_dup              sqlite3_api->value_dup
-#define sqlite3_value_free             sqlite3_api->value_free
-#define sqlite3_result_zeroblob64      sqlite3_api->result_zeroblob64
-#define sqlite3_bind_zeroblob64        sqlite3_api->bind_zeroblob64
-/* Version 3.9.0 and later */
-#define sqlite3_value_subtype          sqlite3_api->value_subtype
-#define sqlite3_result_subtype         sqlite3_api->result_subtype
-/* Version 3.10.0 and later */
-#define sqlite3_status64               sqlite3_api->status64
-#define sqlite3_strlike                sqlite3_api->strlike
-#define sqlite3_db_cacheflush          sqlite3_api->db_cacheflush
-/* Version 3.12.0 and later */
-#define sqlite3_system_errno           sqlite3_api->system_errno
-/* Version 3.14.0 and later */
-#define sqlite3_trace_v2               sqlite3_api->trace_v2
-#define sqlite3_expanded_sql           sqlite3_api->expanded_sql
-/* Version 3.18.0 and later */
-#define sqlite3_set_last_insert_rowid  sqlite3_api->set_last_insert_rowid
-#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
-
-#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
-  /* This case when the file really is being compiled as a loadable 
-  ** extension */
-# define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
-# define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;
-# define SQLITE_EXTENSION_INIT3     \
-    extern const sqlite3_api_routines *sqlite3_api;
-#else
-  /* This case when the file is being statically linked into the 
-  ** application */
-# define SQLITE_EXTENSION_INIT1     /*no-op*/
-# define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
-# define SQLITE_EXTENSION_INIT3     /*no-op*/
-#endif
-
-#endif /* SQLITE3EXT_H */

jni/utils/file.c

@@ -0,0 +1,405 @@
+/* file.c - Contains all files related utilities
+ */
+
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/sendfile.h>
+#include <sys/mman.h>
+#include <linux/fs.h>
+
+#ifndef NO_SELINUX
+#include <selinux/selinux.h>
+#endif
+
+#include "utils.h"
+
+char **excl_list = (char *[]) { NULL };
+
+static int is_excl(const char *name) {
+	for (int i = 0; excl_list[i]; ++i) {
+		if (strcmp(name, excl_list[i]) == 0)
+			return 1;
+	}
+	return 0;
+}
+
+int fd_getpath(int fd, char *path, size_t size) {
+	snprintf(path, size, "/proc/self/fd/%d", fd);
+	if (xreadlink(path, path, size) == -1)
+		return -1;
+	return 0;
+}
+
+int mkdir_p(const char *pathname, mode_t mode) {
+	char *path = strdup(pathname), *p;
+	errno = 0;
+	for (p = path + 1; *p; ++p) {
+		if (*p == '/') {
+			*p = '\0';
+			if (mkdir(path, mode) == -1) {
+				if (errno != EEXIST)
+					return -1;
+			}
+			*p = '/';
+		}
+	}
+	if (mkdir(path, mode) == -1) {
+		if (errno != EEXIST)
+			return -1;
+	}
+	free(path);
+	return 0;
+}
+
+void rm_rf(const char *path) {
+	int fd = xopen(path, O_RDONLY | O_CLOEXEC);
+	if (fd < 0)
+		return;
+	frm_rf(fd);
+	close(fd);
+	rmdir(path);
+}
+
+void frm_rf(int dirfd) {
+	struct dirent *entry;
+	int newfd;
+	DIR *dir = xfdopendir(dirfd);
+
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (is_excl(entry->d_name))
+			continue;
+		switch (entry->d_type) {
+		case DT_DIR:
+			newfd = xopenat(dirfd, entry->d_name, O_RDONLY | O_CLOEXEC);
+			frm_rf(newfd);
+			close(newfd);
+			unlinkat(dirfd, entry->d_name, AT_REMOVEDIR);
+			break;
+		default:
+			unlinkat(dirfd, entry->d_name, 0);
+			break;
+		}
+	}
+}
+
+/* This will only on the same file system */
+void mv_f(const char *source, const char *destination) {
+	struct stat st;
+	xlstat(source, &st);
+	int src, dest;
+	struct file_attr a;
+
+	if (S_ISDIR(st.st_mode)) {
+		xmkdir_p(destination, st.st_mode & 0777);
+		src = xopen(source, O_RDONLY | O_CLOEXEC);
+		dest = xopen(destination, O_RDONLY | O_CLOEXEC);
+		fclone_attr(src, dest);
+		mv_dir(src, dest);
+		close(src);
+		close(dest);
+	} else{
+		getattr(source, &a);
+		xrename(source, destination);
+		setattr(destination, &a);
+	}
+	rmdir(source);
+}
+
+/* This will only on the same file system */
+void mv_dir(int src, int dest) {
+	struct dirent *entry;
+	DIR *dir;
+	int newsrc, newdest;
+	struct file_attr a;
+
+	dir = xfdopendir(src);
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (is_excl(entry->d_name))
+			continue;
+		getattrat(src, entry->d_name, &a);
+		switch (entry->d_type) {
+		case DT_DIR:
+			xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
+			newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
+			newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
+			fsetattr(newdest, &a);
+			mv_dir(newsrc, newdest);
+			close(newsrc);
+			close(newdest);
+			unlinkat(src, entry->d_name, AT_REMOVEDIR);
+			break;
+		case DT_LNK:
+		case DT_REG:
+			renameat(src, entry->d_name, dest, entry->d_name);
+			setattrat(dest, entry->d_name, &a);
+			break;
+		}
+	}
+}
+
+void cp_afc(const char *source, const char *destination) {
+	int src, dest;
+	struct file_attr a;
+	getattr(source, &a);
+
+	if (S_ISDIR(a.st.st_mode)) {
+		xmkdir_p(destination, a.st.st_mode & 0777);
+		src = xopen(source, O_RDONLY | O_CLOEXEC);
+		dest = xopen(destination, O_RDONLY | O_CLOEXEC);
+		fsetattr(dest, &a);
+		clone_dir(src, dest);
+		close(src);
+		close(dest);
+	} else{
+		unlink(destination);
+		if (S_ISREG(a.st.st_mode)) {
+			src = xopen(source, O_RDONLY);
+			dest = xopen(destination, O_WRONLY | O_CREAT | O_TRUNC);
+			xsendfile(dest, src, NULL, a.st.st_size);
+			fsetattr(src, &a);
+			close(src);
+			close(dest);
+		} else if (S_ISLNK(a.st.st_mode)) {
+			char buf[PATH_MAX];
+			xreadlink(source, buf, sizeof(buf));
+			xsymlink(buf, destination);
+			setattr(destination, &a);
+		}
+	}
+}
+
+void clone_dir(int src, int dest) {
+	struct dirent *entry;
+	DIR *dir;
+	int srcfd, destfd, newsrc, newdest;
+	char buf[PATH_MAX];
+	struct file_attr a;
+
+	dir = xfdopendir(src);
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (is_excl(entry->d_name))
+			continue;
+		getattrat(src, entry->d_name, &a);
+		switch (entry->d_type) {
+		case DT_DIR:
+			xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
+			setattrat(dest, entry->d_name, &a);
+			newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
+			newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
+			clone_dir(newsrc, newdest);
+			close(newsrc);
+			close(newdest);
+			break;
+		case DT_REG:
+			destfd = xopenat(dest, entry->d_name, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC);
+			srcfd = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
+			xsendfile(destfd, srcfd, 0, a.st.st_size);
+			fsetattr(destfd, &a);
+			close(destfd);
+			close(srcfd);
+			break;
+		case DT_LNK:
+			xreadlinkat(src, entry->d_name, buf, sizeof(buf));
+			symlinkat(buf, dest, entry->d_name);
+			setattrat(dest, entry->d_name, &a);
+			break;
+		}
+	}
+}
+
+int getattr(const char *path, struct file_attr *a) {
+	if (xlstat(path, &a->st) == -1)
+		return -1;
+	char *con = "";
+#ifndef NO_SELINUX
+	if (lgetfilecon(path, &con) == -1)
+		return -1;
+	strcpy(a->con, con);
+	freecon(con);
+#else
+	a->con[0] = '\0';
+#endif
+	return 0;
+}
+
+int getattrat(int dirfd, const char *pathname, struct file_attr *a) {
+	int fd = xopenat(dirfd, pathname, O_PATH | O_NOFOLLOW | O_CLOEXEC);
+	if (fd < 0)
+		return -1;
+	int ret = fgetattr(fd, a);
+	close(fd);
+	return ret;
+}
+
+int fgetattr(int fd, struct file_attr *a) {
+#ifndef NO_SELINUX
+	char path[PATH_MAX];
+	fd_getpath(fd, path, sizeof(path));
+	return getattr(path, a);
+#else
+	if (fstat(fd, &a->st) == -1)
+		return -1;
+	a->con[0] = '\0';
+	return 0;
+#endif
+}
+
+int setattr(const char *path, struct file_attr *a) {
+	if (chmod(path, a->st.st_mode & 0777) < 0)
+		return -1;
+	if (chown(path, a->st.st_uid, a->st.st_gid) < 0)
+		return -1;
+#ifndef NO_SELINUX
+	if (strlen(a->con) && lsetfilecon(path, a->con) < 0)
+		return -1;
+#endif
+	return 0;
+}
+
+int setattrat(int dirfd, const char *pathname, struct file_attr *a) {
+	int fd = xopenat(dirfd, pathname, O_PATH | O_NOFOLLOW | O_CLOEXEC);
+	if (fd < 0)
+		return -1;
+	int ret = fsetattr(fd, a);
+	close(fd);
+	return ret;
+}
+
+int fsetattr(int fd, struct file_attr *a) {
+#ifndef NO_SELINUX
+	char path[PATH_MAX];
+	fd_getpath(fd, path, sizeof(path));
+	return setattr(path, a);
+#else
+	if (fchmod(fd, a->st.st_mode & 0777) < 0)
+		return -1;
+	if (fchown(fd, a->st.st_uid, a->st.st_gid) < 0)
+		return -1;
+	return 0;
+#endif
+}
+
+void clone_attr(const char *source, const char *target) {
+	struct file_attr a;
+	getattr(source, &a);
+	setattr(target, &a);
+}
+
+void fclone_attr(const int sourcefd, const int targetfd) {
+	struct file_attr a;
+	fgetattr(sourcefd, &a);
+	fsetattr(targetfd, &a);
+}
+
+#ifndef NO_SELINUX
+
+#define UNLABEL_CON "u:object_r:unlabeled:s0"
+#define SYSTEM_CON  "u:object_r:system_file:s0"
+
+void restorecon(int dirfd, int force) {
+	struct dirent *entry;
+	DIR *dir;
+	int fd;
+	char path[PATH_MAX], *con;
+
+	fd_getpath(dirfd, path, sizeof(path));
+	lgetfilecon(path, &con);
+	if (force || strlen(con) == 0 || strcmp(con, UNLABEL_CON) == 0)
+		lsetfilecon(path, SYSTEM_CON);
+	freecon(con);
+
+	dir = xfdopendir(dirfd);
+	while ((entry = xreaddir(dir))) {
+		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+			continue;
+		if (entry->d_type == DT_DIR) {
+			fd = xopenat(dirfd, entry->d_name, O_RDONLY | O_CLOEXEC);
+			restorecon(fd, force);
+		} else {
+			fd = xopenat(dirfd, entry->d_name, O_PATH | O_NOFOLLOW | O_CLOEXEC);
+			fd_getpath(fd, path, sizeof(path));
+			lgetfilecon(path, &con);
+			if (force || strlen(con) == 0 || strcmp(con, UNLABEL_CON) == 0)
+				lsetfilecon(path, SYSTEM_CON);
+			freecon(con);
+		}
+		close(fd);
+	}
+}
+
+#endif   // NO_SELINUX
+
+static void _mmap(int rw, const char *filename, void **buf, size_t *size) {
+	struct stat st;
+	stat(filename, &st);
+	int fd = xopen(filename, rw ? O_RDWR : O_RDONLY);
+	if (S_ISBLK(st.st_mode))
+		ioctl(fd, BLKGETSIZE64, size);
+	else
+		*size = st.st_size;
+	*buf = *size > 0 ? xmmap(NULL, *size, PROT_READ | (rw ? PROT_WRITE : 0), MAP_SHARED, fd, 0) : NULL;
+	close(fd);
+}
+
+void mmap_ro(const char *filename, void **buf, size_t *size) {
+	_mmap(0, filename, buf, size);
+}
+
+void mmap_rw(const char *filename, void **buf, size_t *size) {
+	_mmap(1, filename, buf, size);
+}
+
+void full_read(int fd, void **buf, size_t *size) {
+	size_t cap = 1 << 20;
+	uint8_t tmp[1 << 20];
+	*buf = xmalloc(cap);
+	ssize_t read;
+	*size = 0;
+	while (1) {
+		read = xread(fd, tmp, sizeof(tmp));
+		if (read <= 0)
+			break;
+		if (*size + read > cap) {
+			cap *= 2;
+			*buf = realloc(*buf, cap);
+		}
+		memcpy(*buf + *size, tmp, read);
+		*size += read;
+	}
+}
+
+void write_zero(int fd, size_t size) {
+	size_t pos = lseek(fd, 0, SEEK_CUR);
+	ftruncate(fd, pos + size);
+	lseek(fd, pos + size, SEEK_SET);
+}
+
+void mem_align(size_t *pos, size_t align) {
+	size_t mask = align - 1;
+	if (*pos & mask) {
+		*pos += align - (*pos & mask);
+	}
+}
+
+void file_align(int fd, size_t align, int out) {
+	size_t pos = lseek(fd, 0, SEEK_CUR);
+	size_t mask = align - 1;
+	size_t off;
+	if (pos & mask) {
+		off = align - (pos & mask);
+		if (out) {
+			write_zero(fd, off);
+		} else {
+			lseek(fd, pos + off, SEEK_SET);
+		}
+	}
+}

jni/utils/img.c

@@ -0,0 +1,231 @@
+/* img.c - All image related functions
+ */
+
+#include <unistd.h>
+#include <libgen.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/mount.h>
+#include <linux/loop.h>
+
+#include "magisk.h"
+#include "utils.h"
+
+static int e2fsck(const char *img) {
+	// Check and repair ext4 image
+	char buffer[128];
+	int pid, fd = -1;
+	pid = exec_command(1, &fd, NULL, "e2fsck", "-yf", img, NULL);
+	if (pid < 0)
+		return 1;
+	while (fdgets(buffer, sizeof(buffer), fd))
+		LOGD("magisk_img: %s", buffer);
+	waitpid(pid, NULL, 0);
+	close(fd);
+	return 0;
+}
+
+static char *loopsetup(const char *img) {
+	char device[20];
+	struct loop_info64 info;
+	int i, lfd, ffd;
+	memset(&info, 0, sizeof(info));
+	// First get an empty loop device
+	for (i = 0; i <= 7; ++i) {
+		sprintf(device, "/dev/block/loop%d", i);
+		lfd = xopen(device, O_RDWR);
+		if (ioctl(lfd, LOOP_GET_STATUS64, &info) == -1)
+			break;
+		close(lfd);
+	}
+	if (i == 8) return NULL;
+	ffd = xopen(img, O_RDWR);
+	if (ioctl(lfd, LOOP_SET_FD, ffd) == -1)
+		return NULL;
+	strcpy((char *) info.lo_file_name, img);
+	ioctl(lfd, LOOP_SET_STATUS64, &info);
+	close(lfd);
+	close(ffd);
+	return strdup(device);
+}
+
+int create_img(const char *img, int size) {
+	unlink(img);
+	LOGI("Create %s with size %dM\n", img, size);
+	int ret;
+
+	char buffer[16];
+	snprintf(buffer, sizeof(buffer), "%dM", size);
+	ret = exec_command_sync("make_ext4fs", "-l", buffer, img, NULL);
+	if (ret < 0)
+		return 1;
+	return ret;
+}
+
+int get_img_size(const char *img, int *used, int *total) {
+	if (access(img, R_OK) == -1)
+		return 1;
+	char buffer[PATH_MAX];
+	int pid, fd = -1, status = 1;
+	pid = exec_command(1, &fd, NULL, "e2fsck", "-n", img, NULL);
+	if (pid < 0)
+		return 1;
+	while (fdgets(buffer, sizeof(buffer), fd)) {
+		if (strstr(buffer, img)) {
+			char *tok = strtok(buffer, ",");
+			while(tok != NULL) {
+				if (strstr(tok, "blocks")) {
+					status = 0;
+					break;
+				}
+				tok = strtok(NULL, ",");
+			}
+			if (status) continue;
+			sscanf(tok, "%d/%d", used, total);
+			*used = *used / 256 + 1;
+			*total /= 256;
+			break;
+		}
+	}
+	close(fd);
+	waitpid(pid, NULL, 0);
+	return 0;
+}
+
+int resize_img(const char *img, int size) {
+	LOGI("Resize %s to %dM\n", img, size);
+	if (e2fsck(img))
+		return 1;
+	char buffer[128];
+	int pid, fd = -1, used, total;
+	snprintf(buffer, sizeof(buffer), "%dM", size);
+	pid = exec_command(1, &fd, NULL, "resize2fs", img, buffer, NULL);
+	if (pid < 0)
+		return 1;
+	while (fdgets(buffer, sizeof(buffer), fd))
+		LOGD("magisk_img: %s", buffer);
+	close(fd);
+	waitpid(pid, NULL, 0);
+
+	// Double check our image size
+	get_img_size(img, &used, &total);
+	if (total != size) {
+		// Sammy crap occurs or resize2fs failed, lets create a new image!
+		char *dir = dirname(img);
+		snprintf(buffer, sizeof(buffer), "%s/tmp.img", dir);
+		create_img(buffer, size);
+		char *s_loop, *t_loop;
+		s_loop = mount_image(img, SOURCE_TMP);
+		if (s_loop == NULL) return 1;
+		t_loop = mount_image(buffer, TARGET_TMP);
+		if (t_loop == NULL) return 1;
+
+		cp_afc(SOURCE_TMP, TARGET_TMP);
+		umount_image(SOURCE_TMP, s_loop);
+		umount_image(TARGET_TMP, t_loop);
+		rmdir(SOURCE_TMP);
+		rmdir(TARGET_TMP);
+		free(s_loop);
+		free(t_loop);
+		rename(buffer, img);
+	}
+
+	return 0;
+}
+
+char *mount_image(const char *img, const char *target) {
+	if (access(img, F_OK) == -1)
+		return NULL;
+	if (access(target, F_OK) == -1) {
+		if (xmkdir_p(target, 0755) == -1) {
+			xmount(NULL, "/", NULL, MS_REMOUNT, NULL);
+			xmkdir_p(target, 0755);
+			xmount(NULL, "/", NULL, MS_REMOUNT | MS_RDONLY, NULL);
+		}
+	}
+
+	if (e2fsck(img))
+		return NULL;
+
+	char *device = loopsetup(img);
+	if (device)
+		xmount(device, target, "ext4", 0, NULL);
+	return device;
+}
+
+void umount_image(const char *target, const char *device) {
+	xumount(target);
+	int fd = xopen(device, O_RDWR);
+	ioctl(fd, LOOP_CLR_FD);
+	close(fd);
+}
+
+int merge_img(const char *source, const char *target) {
+	if (access(source, F_OK) == -1)
+		return 0;
+	LOGI("* Merging %s  -> %s\n", source, target);
+	if (access(target, F_OK) == -1) {
+		xrename(source, target);
+		return 0;
+	}
+
+	char buffer[PATH_MAX];
+
+	// resize target to worst case
+	int s_used, s_total, t_used, t_total, n_total;
+	get_img_size(source, &s_used, &s_total);
+	get_img_size(target, &t_used, &t_total);
+	n_total = round_size(s_used + t_used);
+	if (n_total > t_total)
+		resize_img(target, n_total);
+
+	xmkdir(SOURCE_TMP, 0755);
+	xmkdir(TARGET_TMP, 0755);
+	char *s_loop, *t_loop;
+	s_loop = mount_image(source, SOURCE_TMP);
+	if (s_loop == NULL) return 1;
+	t_loop = mount_image(target, TARGET_TMP);
+	if (t_loop == NULL) return 1;
+
+	DIR *dir;
+	struct dirent *entry;
+	if (!(dir = xopendir(SOURCE_TMP)))
+		return 1;
+	while ((entry = xreaddir(dir))) {
+		if (entry->d_type == DT_DIR) {
+			if (strcmp(entry->d_name, ".") == 0 ||
+				strcmp(entry->d_name, "..") == 0 ||
+				strcmp(entry->d_name, ".core") == 0 ||
+				strcmp(entry->d_name, "lost+found") == 0)
+				continue;
+			// Cleanup old module if exists
+			snprintf(buffer, sizeof(buffer), "%s/%s", TARGET_TMP, entry->d_name);
+			if (access(buffer, F_OK) == 0) {
+				LOGI("Upgrade module: %s\n", entry->d_name);
+				rm_rf(buffer);
+			} else {
+				LOGI("New module: %s\n", entry->d_name);
+			}
+		}
+	}
+	closedir(dir);
+	cp_afc(SOURCE_TMP, TARGET_TMP);
+
+	// Unmount all loop devices
+	umount_image(SOURCE_TMP, s_loop);
+	umount_image(TARGET_TMP, t_loop);
+	rmdir(SOURCE_TMP);
+	rmdir(TARGET_TMP);
+	free(s_loop);
+	free(t_loop);
+	unlink(source);
+	return 0;
+}
+
+void trim_img(const char *img) {
+	int used, total, new_size;
+	get_img_size(img, &used, &total);
+	new_size = round_size(used);
+	if (new_size != total)
+		resize_img(img, new_size);
+}

jni/utils/list.c

@@ -24,15 +24,19 @@ void list_insert_end(struct list_head *head, struct list_head *node) {
 	list_insert(head->prev, node);
 }
 
-void list_pop(struct list_head *pos) {
+struct list_head *list_pop(struct list_head *pos) {
+	struct list_head *ret;
+	ret = pos->prev;
 	// Maintain the list
 	pos->prev->next = pos->next;
 	pos->next->prev = pos->prev;
 	// Remove references
 	pos->next = pos;
 	pos->prev = pos;
+	// Return the previous node in the list
+	return ret;
 }
 
-void list_pop_end(struct list_head *head) {
+struct list_head *list_pop_end(struct list_head *head) {
 	return list_pop(head->prev);
 }

jni/utils/list.h

@@ -1,30 +0,0 @@
-/* list.h - Double link list implementation
- */
-
-#ifndef _LIST_H_
-#define _LIST_H_
-
-#include <stddef.h>
-
-struct list_head {
-	struct list_head *next;
-	struct list_head *prev;
-};
-
-void init_list_head(struct list_head *head);
-void list_insert(struct list_head *pos, struct list_head *node);
-void list_insert_end(struct list_head *head, struct list_head *node);
-void list_pop(struct list_head *pos);
-void list_pop_end(struct list_head *head);
-
-#define list_entry(ptr, type, member) ({ \
-	const typeof( ((type *)0)->member ) *__mptr = (ptr); \
-	(type *)( (char *)__mptr - offsetof(type,member) );})
-
-#define list_for_each(pos, head) \
-	for (pos = (head)->next; pos != (head); pos = pos->next)
-
-#define list_for_each_r(pos, head) \
-	for (pos = (head)->prev; pos != (head); pos = pos->prev)
-
-#endif

jni/utils/misc.c

@@ -5,21 +5,18 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <dirent.h>
-#include <unistd.h>
+#include <stdarg.h>
 #include <fcntl.h>
 #include <pwd.h>
 #include <signal.h>
-#include <errno.h>
 #include <sched.h>
+#include <unistd.h>
 #include <sys/types.h>
-#include <sys/ioctl.h>
 #include <sys/mount.h>
 #include <sys/wait.h>
 #include <sys/stat.h>
-#include <selinux/selinux.h>
 
-#include "magisk.h"
+#include "logging.h"
 #include "utils.h"
 
 int quit_signals[] = { SIGALRM, SIGABRT, SIGHUP, SIGPIPE, SIGQUIT, SIGTERM, SIGINT, 0 };
@@ -69,7 +66,7 @@ int file_to_vector(const char* filename, struct vector *v) {
 	size_t len = 0;
 	ssize_t read;
 
-	FILE *fp = fopen(filename, "r");
+	FILE *fp = xfopen(filename, "r");
 	if (fp == NULL)
 		return 1;
 
@@ -97,7 +94,7 @@ int vector_to_file(const char *filename, struct vector *v) {
 }
 
 /* Check if the string only contains digits */
-int isNum(const char *s) {
+static int is_num(const char *s) {
 	int len = strlen(s);
 	for (int i = 0; i < len; ++i)
 		if (s[i] < '0' || s[i] > '9')
@@ -129,11 +126,11 @@ void ps(void (*func)(int)) {
 
 	while ((entry = xreaddir(dir))) {
 		if (entry->d_type == DT_DIR) {
-			if (isNum(entry->d_name))
+			if (is_num(entry->d_name))
 				func(atoi(entry->d_name));
 		}
 	}
-	
+
 	closedir(dir);
 }
 
@@ -144,12 +141,12 @@ static void proc_name_filter(int pid) {
 	char buf[64];
 	int fd;
 	snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid);
-	if ((fd = open(buf, O_RDONLY)) == -1)
+	if (access(buf, R_OK) == -1 || (fd = xopen(buf, O_RDONLY)) == -1)
 		return;
 	if (fdgets(buf, sizeof(buf), fd) == 0) {
 		snprintf(buf, sizeof(buf), "/proc/%d/comm", pid);
 		close(fd);
-		if ((fd = open(buf, O_RDONLY)) == -1)
+		if (access(buf, R_OK) == -1 || (fd = xopen(buf, O_RDONLY)) == -1)
 			return;
 		fdgets(buf, sizeof(buf), fd);
 	}
@@ -166,48 +163,25 @@ void ps_filter_proc_name(const char *pattern, void (*func)(int)) {
 	ps(proc_name_filter);
 }
 
-int create_links(const char *bin, const char *path) {
-	char self[PATH_MAX], linkpath[PATH_MAX];
-	if (bin == NULL) {
-		xreadlink("/proc/self/exe", self, sizeof(self));
-		bin = self;
-	}
-	int ret = 0;
-	for (int i = 0; applet[i]; ++i) {
-		snprintf(linkpath, sizeof(linkpath), "%s/%s", path, applet[i]);
-		unlink(linkpath);
-		ret |= symlink(bin, linkpath);
-	}
-	return ret;
-}
-
-#define DEV_BLOCK "/dev/block"
-
-void unlock_blocks() {	
-	char path[PATH_MAX];
+void unlock_blocks() {
 	DIR *dir;
 	struct dirent *entry;
-	int fd, OFF = 0;
+	int fd, dev, OFF = 0;
 
-	if (!(dir = xopendir(DEV_BLOCK)))
+	if ((dev = xopen("/dev/block", O_RDONLY | O_CLOEXEC)) < 0)
 		return;
+	dir = xfdopendir(dev);
 
 	while((entry = readdir(dir))) {
-		if (entry->d_type == DT_BLK &&
-			strstr(entry->d_name, "ram") == NULL &&
-			strstr(entry->d_name, "loop") == NULL &&
-			strstr(entry->d_name, "dm-0") == NULL) {
-			snprintf(path, sizeof(path), "%s/%s", DEV_BLOCK, entry->d_name);
-			if ((fd = xopen(path, O_RDONLY)) < 0)
+		if (entry->d_type == DT_BLK) {
+			if ((fd = openat(dev, entry->d_name, O_RDONLY)) < 0)
 				continue;
-
 			if (ioctl(fd, BLKROSET, &OFF) == -1)
-				PLOGE("unlock %s", path);
+				PLOGE("unlock %s", entry->d_name);
 			close(fd);
 		}
 	}
-
-	closedir(dir);
+	close(dev);
 }
 
 void setup_sighandlers(void (*handler)(int)) {
@@ -221,245 +195,101 @@ void setup_sighandlers(void (*handler)(int)) {
 
 /*
    fd == NULL -> Ignore output
-  *fd == 0    -> Open pipe and set *fd to the read end
-  *fd != 0    -> STDOUT (or STDERR) will be redirected to *fd
+  *fd < 0     -> Open pipe and set *fd to the read end
+  *fd >= 0    -> STDOUT (or STDERR) will be redirected to *fd
+  *cb         -> A callback function which runs after fork
 */
-int run_command(int err, int *fd, const char *path, char *const argv[]) {
-	int pipefd[2], writeEnd = 0;
+static int v_exec_command(int err, int *fd, void (*setupenv)(struct vector*), const char *argv0, va_list argv) {
+	int pipefd[2], writeEnd = -1;
 
 	if (fd) {
-		if (*fd == 0) {
-			if (pipe(pipefd) == -1)
+		if (*fd < 0) {
+			if (xpipe2(pipefd, O_CLOEXEC) == -1)
 				return -1;
 			writeEnd = pipefd[1];
-			// Give the read end of the pipe
-			*fd = pipefd[0];
+		} else {
+			writeEnd = *fd;
 		}
 	}
 
-	int pid = fork();
+	// Collect va_list into vector
+	struct vector args;
+	vec_init(&args);
+	vec_push_back(&args, strdup(argv0));
+	for (void *arg = va_arg(argv, void*); arg; arg = va_arg(argv, void*))
+		vec_push_back(&args, strdup(arg));
+	vec_push_back(&args, NULL);
+
+	// Setup environment
+	char *const *envp;
+	struct vector env;
+	vec_init(&env);
+	if (setupenv) {
+		setupenv(&env);
+		envp = (char **) vec_entry(&env);
+	} else {
+		extern char **environ;
+		envp = environ;
+	}
+
+	int pid = xfork();
 	if (pid != 0) {
-		if (writeEnd) close(writeEnd);
+		if (fd && *fd < 0) {
+			// Give the read end and close write end
+			*fd = pipefd[0];
+			close(pipefd[1]);
+		}
+		vec_deep_destroy(&args);
+		vec_deep_destroy(&env);
 		return pid;
 	}
 
 	if (fd) {
-		if (writeEnd == 0) writeEnd = *fd;
 		xdup2(writeEnd, STDOUT_FILENO);
 		if (err) xdup2(writeEnd, STDERR_FILENO);
 	}
 
-	execv(path, argv);
-	PLOGE("execv");
+	execvpe(argv0, (char **) vec_entry(&args), envp);
+	PLOGE("execvpe");
 	return -1;
 }
 
-int mkdir_p(const char *pathname, mode_t mode) {
-	char *path = strdup(pathname), *p;
-	errno = 0;
-	for (p = path + 1; *p; ++p) {
-		if (*p == '/') {
-			*p = '\0';
-			if (mkdir(path, mode) == -1) {
-				if (errno != EEXIST)
-					return -1;
-			}
-			*p = '/';
-		}
-	}
-	if (mkdir(path, mode) == -1) {
-		if (errno != EEXIST)
-			return -1;
-	}
-	free(path);
-	return 0;
+int exec_command_sync(char *const argv0, ...) {
+	va_list argv;
+	va_start(argv, argv0);
+	int pid, status;
+	pid = v_exec_command(0, NULL, NULL, argv0, argv);
+	va_end(argv);
+	if (pid < 0)
+		return pid;
+	waitpid(pid, &status, 0);
+	return WEXITSTATUS(status);
+}
+
+int exec_command(int err, int *fd, void (*setupenv)(struct vector*), const char *argv0, ...) {
+	va_list argv;
+	va_start(argv, argv0);
+	int pid = v_exec_command(err, fd, setupenv, argv0, argv);
+	va_end(argv);
+	return pid;
 }
 
 int bind_mount(const char *from, const char *to) {
 	int ret = xmount(from, to, NULL, MS_BIND, NULL);
-	#ifdef DEBUG
-	LOGD("bind_mount: %s -> %s\n", from, to);
-	#else
+#ifdef MAGISK_DEBUG
+	LOGI("bind_mount: %s -> %s\n", from, to);
+#else
 	LOGI("bind_mount: %s\n", to);
-	#endif
+#endif
 	return ret;
 }
 
-int open_new(const char *filename) {
-	return xopen(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-}
-
-// file/link -> file/link only!!
-int cp_afc(const char *source, const char *target) {
-	struct stat buf;
-	xlstat(source, &buf);
-	unlink(target);
-	char *con;
-	if (S_ISREG(buf.st_mode)) {
-		int sfd, tfd;
-		sfd = xopen(source, O_RDONLY);
-		tfd = xopen(target, O_WRONLY | O_CREAT | O_TRUNC);
-		xsendfile(tfd, sfd, NULL, buf.st_size);
-		fchmod(tfd, buf.st_mode & 0777);
-		fchown(tfd, buf.st_uid, buf.st_gid);
-		fgetfilecon(sfd, &con);
-		fsetfilecon(tfd, con);
-		free(con);
-		close(sfd);
-		close(tfd);
-	} else if (S_ISLNK(buf.st_mode)) {
-		char buffer[PATH_MAX];
-		xreadlink(source, buffer, sizeof(buffer));
-		xsymlink(buffer, target);
-		lgetfilecon(source, &con);
-		lsetfilecon(target, con);
-		free(con);
-	} else {
-		return 1;
-	}
-	return 0;
-}
-
-int clone_dir(const char *source, const char *target) {
-	DIR *dir;
-	struct dirent *entry;
-	char *s_path, *t_path;
-
-	if (!(dir = xopendir(source)))
-		return 1;
-
-	s_path = xmalloc(PATH_MAX);
-	t_path = xmalloc(PATH_MAX);
-
-	mkdir_p(target, 0755);
-	clone_attr(source, target);
-
-	while ((entry = xreaddir(dir))) {
-		if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
-			continue;
-		snprintf(s_path, PATH_MAX, "%s/%s", source, entry->d_name);
-		snprintf(t_path, PATH_MAX, "%s/%s", target, entry->d_name);
-		switch (entry->d_type) {
-		case DT_DIR:
-			clone_dir(s_path, t_path);
-			break;
-		case DT_REG:
-		case DT_LNK:
-			cp_afc(s_path, t_path);
-			break;
-		}
-	}
-	free(s_path);
-	free(t_path);
-
-	closedir(dir);
-	return 0;
-}
-
-int rm_rf(const char *target) {
-	if (access(target, F_OK) == -1)
-		return 0;
-	struct stat buf;
-	xlstat(target, &buf);
-	char *next;
-	if (S_ISDIR(buf.st_mode)) {
-		DIR *dir;
-		struct dirent *entry;
-		if (!(dir = xopendir(target)))
-			return 1;
-		next = xmalloc(PATH_MAX);
-		while ((entry = xreaddir(dir))) {
-			if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
-				continue;
-			snprintf(next, PATH_MAX, "%s/%s", target, entry->d_name);
-			switch (entry->d_type) {
-			case DT_DIR:
-				rm_rf(next);
-				break;
-			case DT_REG:
-			case DT_LNK:
-				unlink(next);
-				break;
-			}
-		}
-		free(next);
-		closedir(dir);
-		rmdir(target);
-	} else if (S_ISREG(buf.st_mode) || S_ISLNK(buf.st_mode)) {
-		unlink(target);
-	} else {
-		return 1;
-	}
-	return 0;
-}
-
-void clone_attr(const char *source, const char *target) {
-	struct stat buf;
-	xstat(source, &buf);
-	chmod(target, buf.st_mode & 0777);
-	chown(target, buf.st_uid, buf.st_gid);
-	char *con;
-	lgetfilecon(source, &con);
-	lsetfilecon(target, con);
-	free(con);
-}
-
 void get_client_cred(int fd, struct ucred *cred) {
 	socklen_t ucred_length = sizeof(*cred);
 	if(getsockopt(fd, SOL_SOCKET, SO_PEERCRED, cred, &ucred_length))
 		PLOGE("getsockopt");
 }
 
-int create_img(const char *img, int size) {
-	unlink(img);
-	LOGI("Create %s with size %dM\n", img, size);
-	// Create a temp file with the file contexts
-	char file_contexts[] = "/magisk(/.*)? u:object_r:system_file:s0\n";
-	int fd = xopen("/dev/file_contexts_image", O_WRONLY | O_CREAT | O_TRUNC, 0644);
-	xwrite(fd, file_contexts, sizeof(file_contexts));
-	close(fd);
-
-	char command[PATH_MAX];
-	snprintf(command, sizeof(command),
-		"make_ext4fs -l %dM -a /magisk -S /dev/file_contexts_image %s", size, img);
-	int ret = system(command);
-	unlink("/dev/file_contexts_image");
-	return ret;
-}
-
-int get_img_size(const char *img, int *used, int *total) {
-	if (access(img, R_OK) == -1)
-		return 1;
-	char buffer[PATH_MAX];
-	snprintf(buffer, sizeof(buffer), "e2fsck -n %s 2>/dev/null | tail -n 1", img);
-	char *const command[] = { "sh", "-c", buffer, NULL };
-	int pid, fd = 0;
-	pid = run_command(0, &fd, "/system/bin/sh", command);
-	fdgets(buffer, sizeof(buffer), fd);
-	close(fd);
-	if (pid == -1)
-		return 1;
-	waitpid(pid, NULL, 0);
-	char *tok;
-	tok = strtok(buffer, ",");
-	while(tok != NULL) {
-		if (strstr(tok, "blocks"))
-			break;
-		tok = strtok(NULL, ",");
-	}
-	sscanf(tok, "%d/%d", used, total);
-	*used = *used / 256 + 1;
-	*total /= 256;
-	return 0;
-}
-
-int resize_img(const char *img, int size) {
-	LOGI("Resize %s to %dM\n", img, size);
-	char buffer[PATH_MAX];
-	snprintf(buffer, PATH_MAX, "e2fsck -yf %s; resize2fs %s %dM;", img, img, size);
-	return system(buffer);
-}
-
 int switch_mnt_ns(int pid) {
 	char mnt[32];
 	snprintf(mnt, sizeof(mnt), "/proc/%d/ns/mnt", pid);
@@ -473,3 +303,14 @@ int switch_mnt_ns(int pid) {
 	close(fd);
 	return ret;
 }
+
+int fork_dont_care() {
+	int pid = xfork();
+	if (pid) {
+		waitpid(pid, NULL, 0);
+		return pid;
+	} else if ((pid = xfork())) {
+		exit(0);
+	}
+	return 0;
+}

jni/utils/xwrap.c

@@ -1,8 +1,8 @@
 /* xwrap.c - wrappers around existing library functions.
  *
- * Functions with the x prefix are wrappers that either succeed or kill the
- * program with an error message, but never return failure. They usually have
- * the same arguments and return value as the function they wrap.
+ * Functions with the x prefix are wrappers that either succeed or log the
+ * error message. They usually have the same arguments and return value
+ * as the function they wrap.
  *
  */
 
@@ -14,6 +14,7 @@
 #include <fcntl.h>
 #include <dirent.h>
 #include <errno.h>
+#include <pthread.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -21,7 +22,7 @@
 #include <sys/mman.h>
 #include <sys/sendfile.h>
 
-#include "magisk.h"
+#include "logging.h"
 #include "utils.h"
 
 FILE *xfopen(const char *pathname, const char *mode) {
@@ -56,6 +57,14 @@ int xopen3(const char *pathname, int flags, mode_t mode) {
 	return fd;
 }
 
+int xopenat(int dirfd, const char *pathname, int flags) {
+	int fd = openat(dirfd, pathname, flags);
+	if (fd < 0) {
+		PLOGE("openat: %s", pathname);
+	}
+	return fd;
+}
+
 ssize_t xwrite(int fd, const void *buf, size_t count) {
 	int ret = write(fd, buf, count);
 	if (count != ret) {
@@ -82,10 +91,10 @@ ssize_t xxread(int fd, void *buf, size_t count) {
 	return ret;
 }
 
-int xpipe(int pipefd[2]) {
-	int ret = pipe(pipefd);
+int xpipe2(int pipefd[2], int flags) {
+	int ret = pipe2(pipefd, flags);
 	if (ret == -1) {
-		PLOGE("pipe");
+		PLOGE("pipe2");
 	}
 	return ret;
 }
@@ -106,6 +115,14 @@ DIR *xopendir(const char *name) {
 	return d;
 }
 
+DIR *xfdopendir(int fd) {
+	DIR *d = fdopendir(fd);
+	if (d == NULL) {
+		PLOGE("fdopendir");
+	}
+	return d;
+}
+
 struct dirent *xreaddir(DIR *dirp) {
 	errno = 0;
 	struct dirent *e = readdir(dirp);
@@ -142,7 +159,7 @@ int xbind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 int xconnect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
 	int ret = connect(sockfd, addr, addrlen);
 	if (ret == -1) {
-		PLOGE("bind");
+		PLOGE("connect");
 	}
 	return ret;
 }
@@ -155,8 +172,8 @@ int xlisten(int sockfd, int backlog) {
 	return ret;
 }
 
-int xaccept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
-	int fd = accept(sockfd, addr, addrlen);
+int xaccept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) {
+	int fd = accept4(sockfd, addr, addrlen, flags);
 	if (fd == -1) {
 		PLOGE("accept");
 	}
@@ -250,7 +267,16 @@ ssize_t xreadlink(const char *pathname, char *buf, size_t bufsiz) {
 		PLOGE("readlink %s", pathname);
 	} else {
 		buf[ret] = '\0';
-		++ret;
+	}
+	return ret;
+}
+
+ssize_t xreadlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz) {
+	ssize_t ret = readlinkat(dirfd, pathname, buf, bufsiz);
+	if (ret == -1) {
+		PLOGE("readlinkat %s", pathname);
+	} else {
+		buf[ret] = '\0';
 	}
 	return ret;
 }
@@ -289,14 +315,6 @@ int xumount2(const char *target, int flags) {
 	return ret;
 }
 
-int xchmod(const char *pathname, mode_t mode) {
-	int ret = chmod(pathname, mode);
-	if (ret == -1) {
-		PLOGE("chmod %s %u", pathname, mode);
-	}
-	return ret;
-}
-
 int xrename(const char *oldpath, const char *newpath) {
 	int ret = rename(oldpath, newpath);
 	if (ret == -1) {
@@ -307,12 +325,28 @@ int xrename(const char *oldpath, const char *newpath) {
 
 int xmkdir(const char *pathname, mode_t mode) {
 	int ret = mkdir(pathname, mode);
-	if (ret == -1) {
+	if (ret == -1 && errno != EEXIST) {
 		PLOGE("mkdir %s %u", pathname, mode);
 	}
 	return ret;
 }
 
+int xmkdir_p(const char *pathname, mode_t mode) {
+	int ret = mkdir_p(pathname, mode);
+	if (ret == -1) {
+		PLOGE("mkdir_p %s", pathname);
+	}
+	return ret;
+}
+
+int xmkdirat(int dirfd, const char *pathname, mode_t mode) {
+	int ret = mkdirat(dirfd, pathname, mode);
+	if (ret == -1 && errno != EEXIST) {
+		PLOGE("mkdirat %s %u", pathname, mode);
+	}
+	return ret;
+}
+
 void *xmmap(void *addr, size_t length, int prot, int flags,
 	int fd, off_t offset) {
 	void *ret = mmap(addr, length, prot, flags, fd, offset);
@@ -330,10 +364,10 @@ ssize_t xsendfile(int out_fd, int in_fd, off_t *offset, size_t count) {
 	return ret;
 }
 
-int xmkdir_p(const char *pathname, mode_t mode) {
-	int ret = mkdir_p(pathname, mode);
+pid_t xfork() {
+	int ret = fork();
 	if (ret == -1) {
-		PLOGE("mkdir_p %s", pathname);
+		PLOGE("fork");
 	}
 	return ret;
 }

scripts/addon.d.sh

@@ -0,0 +1,98 @@
+#!/sbin/sh
+##########################################################################################
+#
+# Magisk Survival Script for ROMs with addon.d support
+# by topjohnwu
+#
+# Inspired by 99-flashafterupdate.sh of osm0sis @ xda-developers
+#
+##########################################################################################
+
+. /tmp/backuptool.functions
+
+main() {
+  # Magisk binaries
+  MAGISKBIN=/data/magisk
+  # This script always runs in recovery
+  BOOTMODE=false
+
+  mount /data 2>/dev/null
+
+  if [ ! -d $MAGISKBIN ]; then
+    echo "! Cannot find Magisk binaries!"
+    exit 1
+  fi
+
+  # Wait for post addon.d processes to finish
+  sleep 5
+
+  # Load utility functions
+  . $MAGISKBIN/util_functions.sh
+
+  ui_print "************************"
+  ui_print "* Magisk v$MAGISK_VER addon.d"
+  ui_print "************************"
+
+  mount_partitions
+
+  api_level_arch_detect
+
+  recovery_actions
+
+  remove_system_su
+
+  find_boot_image
+  [ -z $BOOTIMAGE ] && abort "! Unable to detect boot image"
+  ui_print "- Found boot image: $BOOTIMAGE"
+
+  SOURCEDMODE=true
+  cd $MAGISKBIN
+
+  # Source the boot patcher
+  . $MAGISKBIN/boot_patch.sh "$BOOTIMAGE"
+
+  flash_boot_image new-boot.img "$BOOTIMAGE"
+  rm -f new-boot.img
+
+  if [ -f stock_boot* ]; then
+    rm -f /data/stock_boot* 2>/dev/null
+    is_mounted /data && mv stock_boot* /data
+  fi
+
+  patch_dtbo_image
+
+  if [ -f stock_dtbo* ]; then
+    rm -f /data/stock_dtbo* 2>/dev/null
+    is_mounted /data && mv stock_dtbo* /data
+  fi
+
+  cd /
+  recovery_cleanup
+
+  ui_print "- Done"
+  exit 0
+}
+
+case "$1" in
+  backup)
+    # Stub
+  ;;
+  restore)
+    # Stub
+  ;;
+  pre-backup)
+    # Stub
+  ;;
+  post-backup)
+    # Stub
+  ;;
+  pre-restore)
+    # Stub
+  ;;
+  post-restore)
+    # Get the FD for ui_print
+    OUTFD=`ps | grep -v grep | grep -oE "update(.*)" | cut -d" " -f3`
+    # Run the main function in a parallel subshell
+    (main) &
+  ;;
+esac

scripts/boot_patch.sh

@@ -3,103 +3,99 @@
 #
 # Magisk Boot Image Patcher
 # by topjohnwu
-# 
-# This script should be placed in a directory with at least the following files:
-# 
+#
+# This script should be placed in a directory with the following files:
+#
 # File name       type      Description
-# 
+#
 # boot_patch.sh   script    A script to patch boot. Expect path to boot image as parameter.
 #               (this file) The script will use binaries and files in its same directory
 #                           to complete the patching process
-# magisk          binary    The main binary for all Magisk operations.
-#                           It is also used to patch the sepolicy in the ramdisk.
+# monogisk        binary    The monolithic binary to replace /init
 # magiskboot      binary    A tool to unpack boot image, decompress ramdisk, extract ramdisk
-#                           and patch common patches such as forceencrypt, remove dm-verity.
-# init.magisk.rc  script    A new line will be added to init.rc to import this script.
-#                           All magisk entrypoints are defined here
-# 
+#                           , and patch the ramdisk for Magisk support
+# chromeos        folder    This folder should store all the utilities and keys to sign
+#               (optional)  a chromeos device, used in the tablet Pixel C
+#
 # If the script is not running as root, then the input boot image should be a stock image
 # or have a backup included in ramdisk internally, since we cannot access the stock boot
-# image placed under /data we've created when previously installing
+# image placed under /data we've created when previously installed
 #
 ##########################################################################################
+##########################################################################################
+# Functions
+##########################################################################################
 
-CWD=`pwd`
-cd `dirname $1`
-BOOTIMAGE="`pwd`/`basename $1`"
-cd "$CWD"
+# Pure bash dirname implementation
+dirname_wrap() {
+  case "$1" in
+    */*)
+      dir=${1%/*}
+      [ -z $dir ] && echo "/" || echo $dir
+      ;;
+    *)
+      echo "."
+      ;;
+  esac
+}
 
-if [ -z $BOOTIMAGE ]; then
-  ui_print_wrap "This script requires a boot image as a parameter"
-  exit 1
+# Pure bash basename implementation
+basename_wrap() {
+  echo ${1##*/}
+}
+
+##########################################################################################
+# Initialization
+##########################################################################################
+
+if [ -z $SOURCEDMODE ]; then
+  # Switch to the location of the script file
+  cd "`dirname_wrap "${BASH_SOURCE:-$0}"`"
+  # Load utility functions
+  . ./util_functions.sh
+  # Detect current status
+  mount_partitions
 fi
 
+BOOTIMAGE="$1"
+
+[ -e "$BOOTIMAGE" ] || abort "$BOOTIMAGE does not exist!"
+
 # Presets
 [ -z $KEEPVERITY ] && KEEPVERITY=false
 [ -z $KEEPFORCEENCRYPT ] && KEEPFORCEENCRYPT=false
 
-# Detect whether running as root
-[ `id -u` -eq 0 ] && ROOT=true || ROOT=false
+chmod -R 755 .
 
-# Call ui_print_wrap if exists, or else simply use echo
-# Useful when wrapped in flashable zip
-ui_print_wrap() {
-  type ui_print >/dev/null 2>&1 && ui_print "$1" || echo "$1"
-}
-
-grep_prop() {
-  REGEX="s/^$1=//p"
-  shift
-  FILES=$@
-  if [ -z "$FILES" ]; then
-    FILES='/system/build.prop'
-  fi
-  cat $FILES 2>/dev/null | sed -n "$REGEX" | head -n 1
-}
-
-# --cpio-add <incpio> <mode> <entry> <infile>
-cpio_add() {
-  LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-add ramdisk.cpio $1 $2 $3
-}
-
-# --cpio-extract <incpio> <entry> <outfile>
-cpio_extract() {
-  LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-extract ramdisk.cpio $1 $2
-}
-
-# --cpio-mkdir <incpio> <mode> <entry>
-cpio_mkdir() {
-  LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-mkdir ramdisk.cpio $1 $2
-}
+# Extract magisk if doesn't exist
+[ -e magisk ] || ./magiskinit -x magisk magisk
 
 ##########################################################################################
-# Prework
+# Unpack
 ##########################################################################################
 
-# Switch to the location of the script file
-[ -z $SOURCEDMODE ] && cd "`dirname "${BASH_SOURCE:-$0}"`"
-chmod +x ./*
+migrate_boot_backup
 
-# Detect ARCH
-[ -d /system/lib64 ] && SYSTEMLIB=/system/lib64 || SYSTEMLIB=/system/lib
+CHROMEOS=false
 
-ui_print_wrap "- Unpacking boot image"
-LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --unpack $BOOTIMAGE
+ui_print "- Unpacking boot image"
+./magiskboot --unpack "$BOOTIMAGE"
 
 case $? in
   1 )
-    ui_print_wrap "! Unable to unpack boot image"
-    exit 1
+    abort "! Unable to unpack boot image"
     ;;
   2 )
-    ui_print_wrap "! Sony ELF32 format detected"
-    ui_print_wrap "! Please use BootBridge from @AdrianDC to flash Magisk"
-    exit 1
+    ui_print "- ChromeOS boot image detected"
+    CHROMEOS=true
     ;;
   3 )
-    ui_print_wrap "! Sony ELF64 format detected"
-    ui_print_wrap "! Stock kernel cannot be patched, please use a custom kernel"
-    exit 1
+    ui_print "! Sony ELF32 format detected"
+    abort "! Please use BootBridge from @AdrianDC to flash Magisk"
+    ;;
+  4 )
+    ui_print "! Sony ELF64 format detected"
+    abort "! Stock kernel cannot be patched, please use a custom kernel"
 esac
 
 ##########################################################################################
@@ -107,57 +103,50 @@ esac
 ##########################################################################################
 
 # Test patch status and do restore, after this section, ramdisk.cpio.orig is guaranteed to exist
-ui_print_wrap "- Checking ramdisk status"
-LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-test ramdisk.cpio
+ui_print "- Checking ramdisk status"
+./magiskboot --cpio-test ramdisk.cpio
 case $? in
   0 )  # Stock boot
-    ui_print_wrap "- Stock boot image detected!"
-    ui_print_wrap "- Backing up stock boot image"
-    SHA1=`LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --sha1 $BOOTIMAGE | tail -n 1`
-    STOCKDUMP=stock_boot_${SHA1}.img
-    dd if=$BOOTIMAGE of=$STOCKDUMP
-    LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --compress $STOCKDUMP
+    ui_print "- Stock boot image detected!"
+    ui_print "- Backing up stock boot image"
+    SHA1=`./magiskboot --sha1 "$BOOTIMAGE" 2>/dev/null`
+    STOCKDUMP=stock_boot_${SHA1}.img.gz
+    ./magiskboot --compress "$BOOTIMAGE" $STOCKDUMP
     cp -af ramdisk.cpio ramdisk.cpio.orig
     ;;
   1 )  # Magisk patched
-    ui_print_wrap "- Magisk patched image detected!"
+    ui_print "- Magisk patched image detected!"
     # Find SHA1 of stock boot image
-    if [ -z $SHA1 ]; then
-      LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-extract ramdisk.cpio init.magisk.rc init.magisk.rc.old
-      SHA1=`grep_prop "# STOCKSHA1" init.magisk.rc.old`
-      rm -f init.magisk.rc.old
-    fi
-
+    [ -z $SHA1 ] && SHA1=`./magiskboot --cpio-stocksha1 ramdisk.cpio 2>/dev/null`
     OK=false
-    LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-restore ramdisk.cpio
+    ./magiskboot --cpio-restore ramdisk.cpio
     if [ $? -eq 0 ]; then
-      ui_print_wrap "- Ramdisk restored from internal backup"
+      ui_print "- Ramdisk restored from internal backup"
       OK=true
     else
       # Restore failed
-      ui_print_wrap "! Cannot restore from internal backup"
+      ui_print "! Cannot restore from internal backup"
       # If we are root and SHA1 known, we try to find the stock backup
-      if $ROOT && [ ! -z $SHA1 ]; then
-        STOCKDUMP=/data/stock_boot_${SHA1}.img
-        if [ -f ${STOCKDUMP}.gz ]; then
-          ui_print_wrap "- Stock boot image backup found"
-          LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --decompress ${STOCKDUMP}.gz stock_boot.img
-          LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --unpack stock_boot.img
+      if [ ! -z $SHA1 ]; then
+        STOCKDUMP=/data/stock_boot_${SHA1}.img.gz
+        if [ -f $STOCKDUMP ]; then
+          ui_print "- Stock boot image backup found"
+          ./magiskboot --decompress $STOCKDUMP stock_boot.img
+          ./magiskboot --unpack stock_boot.img
           rm -f stock_boot.img
           OK=true
         fi
       fi
     fi
     if ! $OK; then
-      ui_print_wrap "! Ramdisk restoration incomplete"
-      ui_print_wrap "! Will still try to continue installation"
+      ui_print "! Ramdisk restoration incomplete"
+      ui_print "! Will still try to continue installation"
     fi
     cp -af ramdisk.cpio ramdisk.cpio.orig
     ;;
   2 ) # Other patched
-    ui_print_wrap "! Boot image patched by other programs!"
-    ui_print_wrap "! Please restore stock boot image"
-    exit 1
+    ui_print "! Boot image patched by other programs!"
+    abort "! Please restore stock boot image"
     ;;
 esac
 
@@ -165,56 +154,42 @@ esac
 # Ramdisk patches
 ##########################################################################################
 
-ui_print_wrap "- Patching ramdisk"
+ui_print "- Patching ramdisk"
 
-# The common patches
-$KEEPVERITY || LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-patch-dmverity ramdisk.cpio
-$KEEPFORCEENCRYPT || LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-patch-forceencrypt ramdisk.cpio
-
-# Add magisk entrypoint
-cpio_extract init.rc init.rc
-grep "import /init.magisk.rc" init.rc >/dev/null || sed -i '1,/.*import.*/s/.*import.*/import \/init.magisk.rc\n&/' init.rc
-sed -i "/selinux.reload_policy/d" init.rc
-cpio_add 750 init.rc init.rc
-rm -f init.rc
-
-# sepolicy patches
-cpio_extract sepolicy sepolicy
-LD_LIBRARY_PATH=$SYSTEMLIB ./magisk magiskpolicy --load sepolicy --save sepolicy --minimal
-cpio_add 644 sepolicy sepolicy
-rm -f sepolicy
-
-# Add new items
-if [ ! -z $SHA1 ]; then
-  cp init.magisk.rc init.magisk.rc.bak
-  echo "# STOCKSHA1=$SHA1" >> init.magisk.rc
-fi
-cpio_add 750 init.magisk.rc init.magisk.rc
-[ -f init.magisk.rc.bak ] && mv init.magisk.rc.bak init.magisk.rc
-cpio_add 755 sbin/magisk magisk
+./magiskboot --cpio-add ramdisk.cpio 750 init magiskinit
+./magiskboot --cpio-patch ramdisk.cpio $KEEPVERITY $KEEPFORCEENCRYPT
 
 # Create ramdisk backups
-LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cpio-backup ramdisk.cpio ramdisk.cpio.orig
+./magiskboot --cpio-backup ramdisk.cpio ramdisk.cpio.orig $SHA1
 
 rm -f ramdisk.cpio.orig
 
+##########################################################################################
+# Binary patches
+##########################################################################################
+
+if ! $KEEPVERITY && [ -f dtb ]; then
+  ./magiskboot --dtb-patch dtb && ui_print "- Patching fstab in dtb to remove dm-verity"
+fi
+
+# Remove Samsung RKP in stock kernel
+./magiskboot --hexpatch kernel \
+49010054011440B93FA00F71E9000054010840B93FA00F7189000054001840B91FA00F7188010054 \
+A1020054011440B93FA00F7140020054010840B93FA00F71E0010054001840B91FA00F7181010054
+
+# skip_initramfs -> want_initramfs
+./magiskboot --hexpatch kernel \
+736B69705F696E697472616D6673 \
+77616E745F696E697472616D6673
+
 ##########################################################################################
 # Repack and flash
 ##########################################################################################
 
-# Hexpatches
+ui_print "- Repacking boot image"
+./magiskboot --repack "$BOOTIMAGE" || abort "! Unable to repack boot image!"
 
-# Remove Samsung RKP in stock kernel
-LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --hexpatch kernel \
-49010054011440B93FA00F71E9000054010840B93FA00F7189000054001840B91FA00F7188010054 \
-A1020054011440B93FA00F7140020054010840B93FA00F71E0010054001840B91FA00F7181010054
+# Sign chromeos boot
+$CHROMEOS && sign_chromeos
 
-ui_print_wrap "- Repacking boot image"
-LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --repack $BOOTIMAGE
-
-if [ $? -ne 0 ]; then
-  ui_print_wrap "! Unable to repack boot image!"
-  exit 1
-fi
-
-LD_LIBRARY_PATH=$SYSTEMLIB ./magiskboot --cleanup
+./magiskboot --cleanup

scripts/flash_script.sh

@@ -1,238 +1,76 @@
-#!/sbin/sh
+#MAGISK
 ##########################################################################################
 #
 # Magisk Flash Script
 # by topjohnwu
-# 
+#
 # This script will detect, construct the environment for Magisk
 # It will then call boot_patch.sh to patch the boot image
 #
 ##########################################################################################
 
+##########################################################################################
+# Preparation
+##########################################################################################
+
 # Detect whether in boot mode
 ps | grep zygote | grep -v grep >/dev/null && BOOTMODE=true || BOOTMODE=false
-$BOOTMODE || ps -A | grep zygote | grep -v grep >/dev/null && BOOTMODE=true
+$BOOTMODE || ps -A 2>/dev/null | grep zygote | grep -v grep >/dev/null && BOOTMODE=true
 
 # This path should work in any cases
 TMPDIR=/dev/tmp
 
-INSTALLER=$TMPDIR/magisk
+INSTALLER=$TMPDIR/install
 COMMONDIR=$INSTALLER/common
-BOOTTMP=$TMPDIR/boottmp
-COREDIR=/magisk/.core
+APK=$COMMONDIR/magisk.apk
 CHROMEDIR=$INSTALLER/chromeos
+COREDIR=/magisk/.core
 
 # Default permissions
 umask 022
 
-##########################################################################################
-# Flashable update-binary preparation
-##########################################################################################
-
 OUTFD=$2
 ZIP=$3
 
-readlink /proc/$$/fd/$OUTFD 2>/dev/null | grep /tmp >/dev/null
-if [ "$?" -eq "0" ]; then
-  OUTFD=0
-
-  for FD in `ls /proc/$$/fd`; do
-    readlink /proc/$$/fd/$FD 2>/dev/null | grep pipe >/dev/null
-    if [ "$?" -eq "0" ]; then
-      ps | grep " 3 $FD " | grep -v grep >/dev/null
-      if [ "$?" -eq "0" ]; then
-        OUTFD=$FD
-        break
-      fi
-    fi
-  done
+if [ ! -f $COMMONDIR/util_functions.sh ]; then
+  echo "! Unable to extract zip file!"
+  exit 1
 fi
 
-mkdir -p $INSTALLER
-cd $INSTALLER
-unzip -o "$ZIP"
+# Load utility fuctions
+. $COMMONDIR/util_functions.sh
 
-##########################################################################################
-# Functions
-##########################################################################################
-
-ui_print() {
-  if $BOOTMODE; then
-    echo "$1"
-  else 
-    echo -n -e "ui_print $1\n" >> /proc/self/fd/$OUTFD
-    echo -n -e "ui_print\n" >> /proc/self/fd/$OUTFD
-  fi
-}
-
-getvar() {
-  local VARNAME=$1
-  local VALUE=$(eval echo \$"$VARNAME");
-  for FILE in /dev/.magisk /data/.magisk /cache/.magisk /system/.magisk; do
-    if [ -z "$VALUE" ]; then
-      LINE=$(cat $FILE 2>/dev/null | grep "$VARNAME=")
-      if [ ! -z "$LINE" ]; then
-        VALUE=${LINE#*=}
-      fi
-    fi
-  done
-  eval $VARNAME=\$VALUE
-}
-
-find_boot_image() {
-  if [ -z "$BOOTIMAGE" ]; then
-    for PARTITION in kern-a KERN-A android_boot ANDROID_BOOT kernel KERNEL boot BOOT lnx LNX; do
-      BOOTIMAGE=`readlink /dev/block/by-name/$PARTITION || readlink /dev/block/platform/*/by-name/$PARTITION || readlink /dev/block/platform/*/*/by-name/$PARTITION`
-      if [ ! -z "$BOOTIMAGE" ]; then break; fi
-    done
-  fi
-  if [ -z "$BOOTIMAGE" ]; then
-    FSTAB="/etc/recovery.fstab"
-    [ ! -f "$FSTAB" ] && FSTAB="/etc/recovery.fstab.bak"
-    [ -f "$FSTAB" ] && BOOTIMAGE=`grep -E '\b/boot\b' "$FSTAB" | grep -oE '/dev/[a-zA-Z0-9_./-]*'`
-  fi
-}
-
-is_mounted() {
-  if [ ! -z "$2" ]; then
-    cat /proc/mounts | grep $1 | grep $2, >/dev/null
-  else
-    cat /proc/mounts | grep $1 >/dev/null
-  fi
-  return $?
-}
-
-mount_image() {
-  if [ ! -d "$2" ]; then
-    mount -o rw,remount rootfs /
-    mkdir -p $2 2>/dev/null
-    ($BOOTMODE) && mount -o ro,remount rootfs /
-    [ ! -d "$2" ] && return 1
-  fi
-  if (! is_mounted $2); then
-    LOOPDEVICE=
-    for LOOP in 0 1 2 3 4 5 6 7; do
-      if (! is_mounted $2); then
-        LOOPDEVICE=/dev/block/loop$LOOP
-        if [ ! -f "$LOOPDEVICE" ]; then
-          mknod $LOOPDEVICE b 7 $LOOP 2>/dev/null
-        fi
-        losetup $LOOPDEVICE $1
-        if [ "$?" -eq "0" ]; then
-          mount -t ext4 -o loop $LOOPDEVICE $2
-          if (! is_mounted $2); then
-            /system/bin/toolbox mount -t ext4 -o loop $LOOPDEVICE $2
-          fi
-          if (! is_mounted $2); then
-            /system/bin/toybox mount -t ext4 -o loop $LOOPDEVICE $2
-          fi
-        fi
-        if (is_mounted $2); then
-          ui_print "- Mounting $1 to $2"
-          break;
-        fi
-      fi
-    done
-  fi
-}
-
-grep_prop() {
-  REGEX="s/^$1=//p"
-  shift
-  FILES=$@
-  if [ -z "$FILES" ]; then
-    FILES='/system/build.prop'
-  fi
-  cat $FILES 2>/dev/null | sed -n "$REGEX" | head -n 1
-}
-
-remove_system_su() {
-  if [ -f /system/bin/su -o -f /system/xbin/su ] && [ ! -f /su/bin/su ]; then
-    ui_print "! System installed root detected, mount rw :("
-    mount -o rw,remount /system
-    # SuperSU
-    if [ -e /system/bin/.ext/.su ]; then
-      mv -f /system/bin/app_process32_original /system/bin/app_process32 2>/dev/null
-      mv -f /system/bin/app_process64_original /system/bin/app_process64 2>/dev/null
-      mv -f /system/bin/install-recovery_original.sh /system/bin/install-recovery.sh 2>/dev/null
-      cd /system/bin
-      if [ -e app_process64 ]; then
-        ln -sf app_process64 app_process
-      else
-        ln -sf app_process32 app_process
-      fi
-    fi
-    rm -rf /system/.pin /system/bin/.ext /system/etc/.installed_su_daemon /system/etc/.has_su_daemon \
-    /system/xbin/daemonsu /system/xbin/su /system/xbin/sugote /system/xbin/sugote-mksh /system/xbin/supolicy \
-    /system/bin/app_process_init /system/bin/su /cache/su /system/lib/libsupol.so /system/lib64/libsupol.so \
-    /system/su.d /system/etc/install-recovery.sh /system/etc/init.d/99SuperSUDaemon /cache/install-recovery.sh \
-    /system/.supersu /cache/.supersu /data/.supersu \
-    /system/app/Superuser.apk /system/app/SuperSU /cache/Superuser.apk  2>/dev/null
-  fi
-}
+get_outfd
 
 ##########################################################################################
 # Detection
 ##########################################################################################
 
 ui_print "************************"
-ui_print "* MAGISK_VERSION_STUB"
+ui_print "* Magisk v$MAGISK_VER Installer"
 ui_print "************************"
 
-if [ ! -d "$COMMONDIR" ]; then
-  ui_print "! Failed: Unable to extract zip file!"
-  exit 1
-fi
-
-ui_print "- Mounting /system(ro), /cache, /data"
-mount -o ro /system 2>/dev/null
-mount /cache 2>/dev/null
-mount /data 2>/dev/null
-
-if [ ! -f '/system/build.prop' ]; then
-  ui_print "! Failed: /system could not be mounted!"
-  exit 1
-fi
+is_mounted /data || mount /data || is_mounted /cache || mount /cache || abort "! Unable to mount partitions"
+mount_partitions
 
 # read override variables
 getvar KEEPVERITY
 getvar KEEPFORCEENCRYPT
 getvar BOOTIMAGE
 
+# Detect version and architecture
+api_level_arch_detect
+
+[ $API -lt 21 ] && abort "! Magisk is only for Lollipop 5.0+ (SDK 21+)"
+
 # Check if system root is installed and remove
 remove_system_su
 
-API=`grep_prop ro.build.version.sdk`
-ABI=`grep_prop ro.product.cpu.abi | cut -c-3`
-ABI2=`grep_prop ro.product.cpu.abi2 | cut -c-3`
-ABILONG=`grep_prop ro.product.cpu.abi`
-
-ARCH=arm
-IS64BIT=false
-if [ "$ABI" = "x86" ]; then ARCH=x86; fi;
-if [ "$ABI2" = "x86" ]; then ARCH=x86; fi;
-if [ "$ABILONG" = "arm64-v8a" ]; then ARCH=arm64; IS64BIT=true; fi;
-if [ "$ABILONG" = "x86_64" ]; then ARCH=x64; IS64BIT=true; fi;
-
-
-if [ "$API" -lt "21" ]; then
-  ui_print "! Magisk is only for Lollipop 5.0+ (SDK 21+)"
-  exit 1
-fi
-
 ui_print "- Device platform: $ARCH"
 
 BINDIR=$INSTALLER/$ARCH
 chmod -R 755 $CHROMEDIR $BINDIR
 
-$IS64BIT && SYSTEMLIB=/system/lib64 || SYSTEMLIB=/system/lib
-
-find_boot_image
-if [ -z $BOOTIMAGE ]; then
-  ui_print "! Unable to detect boot image"
-  exit 1
-fi
-
 ##########################################################################################
 # Environment
 ##########################################################################################
@@ -241,106 +79,61 @@ ui_print "- Constructing environment"
 
 is_mounted /data && MAGISKBIN=/data/magisk || MAGISKBIN=/cache/data_bin
 
+# Save our stock boot image dump before removing it
+mv /data/magisk/stock_boot* /data 2>/dev/null
+
 # Copy required files
-rm -rf $MAGISKBIN 2>/dev/null
-mkdir -p $MAGISKBIN
-cp -af $BINDIR/. $COMMONDIR/. $MAGISKBIN
-
+rm -rf $MAGISKBIN/* 2>/dev/null
+mkdir -p $MAGISKBIN 2>/dev/null
+cp -af $BINDIR/. $COMMONDIR/. $CHROMEDIR $TMPDIR/bin/busybox $MAGISKBIN
 chmod -R 755 $MAGISKBIN
-chcon -hR u:object_r:system_file:s0 $MAGISKBIN
 
-##########################################################################################
-# Magisk Image
-##########################################################################################
-
-# Fix SuperSU.....
-$BOOTMODE && $BINDIR/magiskpolicy --live "allow fsck * * *"
-
-if (is_mounted /data); then
-  IMG=/data/magisk.img
-else
-  IMG=/cache/magisk.img
-  ui_print "- Data unavailable, use cache workaround"
+# addon.d
+if [ -d /system/addon.d ]; then
+  ui_print "- Adding addon.d survival script"
+  mount -o rw,remount /system
+  cp -af $INSTALLER/addon.d/99-magisk.sh /system/addon.d/99-magisk.sh
+  chmod 755 /system/addon.d/99-magisk.sh
 fi
 
-if [ -f $IMG ]; then
-  ui_print "- $IMG detected!"
-else
-  ui_print "- Creating $IMG"
-  $BINDIR/magisk --createimg $IMG 64M
-fi
-
-mount_image $IMG /magisk
-if (! is_mounted /magisk); then
-  ui_print "! Magisk image mount failed..."
-  exit 1
-fi
-MAGISKLOOP=$LOOPDEVICE
-
-# Core folders
-mkdir -p $COREDIR/props $COREDIR/post-fs-data.d $COREDIR/service.d 2>/dev/null
-
-chmod -R 755 $COREDIR/post-fs-data.d $COREDIR/service.d
-chown -R 0.0 $COREDIR/post-fs-data.d $COREDIR/service.d
-
-# Legacy cleanup
-mv $COREDIR/magiskhide/hidelist $COREDIR/hidelist 2>/dev/null
-rm -rf $COREDIR/magiskhide $COREDIR/bin
+$BOOTMODE || recovery_actions
 
 ##########################################################################################
-# Unpack boot
+# Boot patching
 ##########################################################################################
 
-ui_print "- Found Boot Image: $BOOTIMAGE"
+[ -z $BOOTIMAGE ] && find_boot_image
+[ -z $BOOTIMAGE ] && abort "! Unable to detect boot image"
+ui_print "- Found boot image: $BOOTIMAGE"
 
-# Update our previous backup to new format if exists
-if [ -f /data/stock_boot.img ]; then
-  SHA1=`LD_LIBRARY_PATH=$SYSTEMLIB $BINDIR/magiskboot --sha1 /data/stock_boot.img | tail -n 1`
-  STOCKDUMP=/data/stock_boot_${SHA1}.img
-  mv /data/stock_boot.img $STOCKDUMP
-  LD_LIBRARY_PATH=$SYSTEMLIB $BINDIR/magiskboot --compress $STOCKDUMP
-fi
+eval $BOOTSIGNER -verify < $BOOTIMAGE && BOOTSIGNED=true
+$BOOTSIGNED && ui_print "- Signed boot image detected"
 
 SOURCEDMODE=true
 cd $MAGISKBIN
 
 # Source the boot patcher
-. $COMMONDIR/boot_patch.sh $BOOTIMAGE
+. $COMMONDIR/boot_patch.sh "$BOOTIMAGE"
 
-# Sign chromeos boot
-if [ -f chromeos ]; then
-  echo > empty
-
-  LD_LIBRARY_PATH=$SYSTEMLIB $CHROMEDIR/futility vbutil_kernel --pack new-boot.img.signed \
-  --keyblock $CHROMEDIR/kernel.keyblock --signprivate $CHROMEDIR/kernel_data_key.vbprivk \
-  --version 1 --vmlinuz new-boot.img --config empty --arch arm --bootloader empty --flags 0x1
-
-  rm -f empty new-boot.img
-  mv new-boot.img.signed new-boot.img
-fi
-
-if is_mounted /data; then
-  rm -f /data/stock_boot*
-  mv stock_boot* /data
-fi
-
-ui_print "- Flashing new boot image"
-if [ -L $BOOTIMAGE ]; then
-  dd if=new-boot.img of=$BOOTIMAGE bs=4096
-else
-  cat new-boot.img /dev/zero | dd of=$BOOTIMAGE bs=4096
-fi
+flash_boot_image new-boot.img "$BOOTIMAGE"
 rm -f new-boot.img
 
-cd /
-
-if ! $BOOTMODE; then
-  ui_print "- Unmounting partitions"
-  umount /magisk
-  losetup -d $MAGISKLOOP 2>/dev/null
-  rmdir /magisk
-  umount /system
+if [ -f stock_boot* ]; then
+  rm -f /data/stock_boot* 2>/dev/null
+  is_mounted /data && mv stock_boot* /data
 fi
 
+patch_dtbo_image
+
+if [ -f stock_dtbo* ]; then
+  rm -f /data/stock_dtbo* 2>/dev/null
+  is_mounted /data && mv stock_dtbo* /data
+fi
+
+cd /
+# Cleanups
+$BOOTMODE || recovery_cleanup
+rm -rf $TMPDIR
+
 ui_print "- Done"
 exit 0

scripts/init.magisk.rc

@@ -1,35 +0,0 @@
-# Triggers
-
-on post-fs
-    start magisk_pfs
-    wait /dev/.magisk.unblock 20
-
-on post-fs-data
-    rm /dev/.magisk.unblock
-    load_persist_props
-    start magisk_pfsd
-    wait /dev/.magisk.unblock 60
-
-on property:magisk.restart_pfsd=1
-    trigger post-fs-data
-
-# Services
-
-# launch post-fs script
-service magisk_pfs /sbin/magisk --post-fs
-    user root
-    seclabel u:r:su:s0
-    oneshot
-
-# launch post-fs-data script
-service magisk_pfsd /sbin/magisk --post-fs-data
-    user root
-    seclabel u:r:su:s0
-    oneshot
-
-# launch late_start script
-service magisk_service /sbin/magisk  --service
-    class late_start
-    user root
-    seclabel u:r:su:s0
-    oneshot