Assembly stores progress

Author: grendello

tools/apput/src/AssemblyStore/AssemblyStore.cs

@@ -1,16 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
 
 using Xamarin.Android.Tools;
 
 namespace ApplicationUtility;
 
 public class AssemblyStore : IAspect
 {
+	const int MinimumStoreSize = 8;
+	const uint MagicNumber = 0x41424158; // 'XABA', little-endian
+
 	public static string AspectName { get; } = "Assembly Store";
 
-	public IDictionary<string, ApplicationAssembly> Assemblies { get; private set; } = null!;
+	public IDictionary<string, ApplicationAssembly> Assemblies { get; private set; } = new Dictionary<string, ApplicationAssembly> (StringComparer.Ordinal);
 	public AndroidTargetArch Architecture { get; private set; } = AndroidTargetArch.None;
 	public ulong NumberOfAssemblies => (ulong)(Assemblies?.Count ?? 0);
 
@@ -21,6 +25,39 @@ public static IAspect LoadAspect (Stream stream, string? description)
 
 	public static bool ProbeAspect (Stream stream, string? description)
 	{
-		throw new NotImplementedException ();
+		// TODO: check if it's an ELF .so and extract the payload, if necessary
+
+		// All assembly store files are at least 8 bytes long - space taken up by
+		// the magic number + store version.
+		if (stream.Length < MinimumStoreSize) {
+			Log.Debug ($"AssemblyStore: stream ('{description}') isn't long enough. Need at least {MinimumStoreSize} bytes");
+			return false;
+		}
+
+		stream.Seek (0, SeekOrigin.Begin);
+		using var reader = new BinaryReader (stream, Encoding.UTF8, leaveOpen: true);
+		uint magic = reader.ReadUInt32 ();
+		if (magic != MagicNumber) {
+			Log.Debug ($"AssemblyStore: stream ('{description}') doesn't have the correct signature.");
+			return false;
+		}
+
+		uint version = reader.ReadUInt32 ();
+
+		// We currently support version 3. Main store version is kept in the lower 16 bits of the version word
+		uint mainVersion = version & 0xFFFF;
+		switch (mainVersion) {
+			case 3:
+				return ValidateFormatVersion3 (stream, description);
+
+			default:
+				Log.Debug ($"AssemblyStore: unsupported store version: {mainVersion}");
+				return false;
+		}
+	}
+
+	static bool ValidateFormatVersion3 (Stream stream, string? description)
+	{
+		return true;
 	}
 }

tools/apput/src/AssemblyStore/AssemblyStoreAbi.cs

@@ -0,0 +1,10 @@
+namespace ApplicationUtility;
+
+// Values correspond to those in `xamarin-app.hh`
+enum AssemblyStoreABI
+{
+	Arm64 = 0x00010000,
+	Arm   = 0x00020000,
+	X86   = 0x00030000,
+	X64   = 0x00040000,
+}

tools/apput/src/AssemblyStore/AssemblyStoreHeader.cs

@@ -0,0 +1,20 @@
+namespace ApplicationUtility;
+
+/// <summary>
+/// Represents a high-level description of the store hader. It means that this class
+/// does **not** correspond to a physical format of the header in the store file. Instead,
+/// it contains all the information gathered from the physical file, in a forward compatible
+/// way. Forward compatibility means that all public the properties are virtual and nullable,
+/// since it's possible that some of them will not be present in the future revisions of the
+/// on-disk structure. No public property shall be removed, but any and all of them may be
+/// `null` for any given version of the assembly store format. The only exception to this rule
+/// is the `Version` property, since it is expected to be present in one way or another in all
+/// the future format revisions.
+/// </summary>
+class AssemblyStoreHeader
+{
+	public AssemblyStoreVersion Version { get; protected set; }
+	public uint? EntryCount { get; protected set; }
+	public uint? IndexEntryCount { get; protected set; }
+	public uint? IndexSize { get; protected set; }
+}

tools/apput/src/AssemblyStore/AssemblyStoreVersion.cs

@@ -0,0 +1,15 @@
+namespace ApplicationUtility;
+
+class AssemblyStoreVersion
+{
+	public uint MainVersion     { get; }
+	public AssemblyStoreABI ABI { get; }
+	public bool Is64Bit         { get; }
+
+	internal AssemblyStoreVersion (uint mainVersion, AssemblyStoreABI abi, bool is64Bit)
+	{
+		MainVersion = mainVersion;
+		ABI = abi;
+		Is64Bit = is64Bit;
+	}
+}

tools/apput/src/AssemblyStore/Format_V3.cs

@@ -0,0 +1,5 @@
+namespace ApplicationUtility;
+
+class Format_V3
+{
+}

tools/apput/src/Common/Utilities.cs

@@ -0,0 +1,34 @@
+using System;
+using System.IO;
+
+namespace ApplicationUtility;
+
+class Utilities
+{
+	public static void DeleteFile (string path, bool quiet = true)
+	{
+		try {
+			File.Delete (path);
+		} catch (Exception ex) {
+			Log.Debug ($"Failed to delete file '{path}'.", ex);
+			if (!quiet) {
+				throw;
+			}
+		}
+	}
+
+	public static void CloseAndDeleteFile (FileStream stream, bool quiet = true)
+	{
+		string path = stream.Name;
+		try {
+			stream.Close ();
+		} catch (Exception ex) {
+			Log.Debug ($"Failed to close file stream.", ex);
+			if (!quiet) {
+				throw;
+			}
+		}
+
+		DeleteFile (path);
+	}
+}

tools/apput/src/Package/ApplicationPackage.cs

@@ -165,14 +165,15 @@ void TryLoadAssemblyStores ()
 	AssemblyStore? TryLoadAssemblyStore (string storePath)
 	{
 		// AssemblyStore class owns the stream, don't dispose it here
-		Stream? storeStream = TryGetEntryStream (storePath);
+		FileStream? storeStream = TryGetEntryStream (storePath);
 		if (storeStream == null) {
 			return null;
 		}
 
 		try {
 			if (!AssemblyStore.ProbeAspect (storeStream, storePath)) {
 				Log.Debug ($"Assembly store '{storePath}' is not in a supported format");
+				storeStream.Close ();
 				return null;
 			}
 
@@ -199,7 +200,7 @@ void TryLoadAndroidManifest ()
 	string GetNativeLibDir (AndroidTargetArch arch) => $"{NativeLibDirBase}/{MonoAndroidHelper.ArchToAbi (arch)}/";
 	string GetNativeLibFile (AndroidTargetArch arch, string fileName) => $"{GetNativeLibDir (arch)}{fileName}";
 
-	Stream? TryGetEntryStream (string path)
+	FileStream? TryGetEntryStream (string path)
 	{
 		try {
 			ZipArchiveEntry? entry = Zip.GetEntry (path);
@@ -208,9 +209,16 @@ void TryLoadAndroidManifest ()
 				return null;
 			}
 
-			return entry.Open ();
+			string tempFile = Path.GetTempFileName ();
+			TempFileManager.RegisterFile (tempFile);
+
+			Log.Debug ($"Extracting entry '{path}' to '{tempFile}'");
+			entry.ExtractToFile (tempFile, overwrite: true);
+			return File.OpenRead (tempFile);
 		} catch (Exception ex) {
 			Log.Debug ($"Failed to load entry '{path}' from the archive.", ex);
+
+			// TODO: remove temp file (using a helper method, which doesn't exist yet)
 			return null;
 		}
 	}

tools/apput/src/Program.cs

@@ -1,10 +1,25 @@
+using System;
+
 namespace ApplicationUtility;
 
 class Program
 {
-    static void Main (string[] args)
-    {
-	    Log.SetVerbose (true);
-	    IAspect? aspect = Detector.FindAspect (args[0]);
-    }
+	static int Main (string[] args)
+	{
+		Log.SetVerbose (true);
+		try {
+			return Run (args);
+		} catch (Exception ex) {
+			Log.ExceptionError ("Unhandled exception", ex);
+			return 1;
+		} finally {
+			TempFileManager.Cleanup ();
+		}
+	}
+
+	static int Run (string[] args)
+	{
+		IAspect? aspect = Detector.FindAspect (args[0]);
+		return 0;
+	}
 }