VfsTable.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
 
using IKVM.Runtime.Extensions;
 
namespace IKVM.Runtime.Vfs
{
 
    internal class VfsTable
    {
 
        public static VfsTable BuildDefaultTable(VfsContext context, string ikvmHome)
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            if (context is null)
                throw new ArgumentNullException(nameof(context));
 
            if (Directory.Exists(ikvmHome) == false)
                throw new DirectoryNotFoundException("Could not locate ikvm.home when establishing VFS.");
 
            var table = new VfsTable(context);
            table.AddMount(Path.Combine(ikvmHome, "assembly"), new VfsAssemblyDirectory(context));
            return table;
#endif
        }
 
        readonly VfsContext context;
        readonly LinkedList<VfsMount> mounts = new LinkedList<VfsMount>();
 
        public VfsTable(VfsContext context)
        {
            this.context = context ?? throw new ArgumentNullException(nameof(context));
        }
 
        public VfsContext Context => context;
 
        public IReadOnlyCollection<VfsMount> Mounts => mounts;
 
        public VfsMount AddMount(string path, VfsEntry item)
        {
            return mounts.AddFirst(new VfsMount(path, item)).Value;
        }
 
        public void RemoveMount(string path)
        {
            var mount = mounts.FirstOrDefault(i => i.Path == path);
            if (mount != null)
                mounts.Remove(mount);
        }
 
        public VfsMount GetMount(string path) => mounts.FirstOrDefault(i => i.IsPath(path));
 
        public bool IsPath(string path) => GetMount(path) is not null;
 
        public VfsEntry GetEntry(string path) => GetMount(path) is VfsMount mount ? mount.GetEntry(path.Substring(mount.Path.Length)) : null;
 
        public string[] List(string path) => GetEntry(path) is VfsDirectory directory ? directory.List() : null;
 
        public Stream Open(string path, FileMode mode, FileAccess access)
        {
            // VFS is currently completely read-only
            if (mode != FileMode.Open || access != FileAccess.Read)
                throw new UnauthorizedAccessException("Virtual file system is read-only.");
 
            // search for the entry in the file system and open it
            return GetEntry(path) switch
            {
                VfsFile file => file.Open(mode, access),
                VfsDirectory => throw new UnauthorizedAccessException($"Access to '{path}' was denied."),
                _ => throw new FileNotFoundException("File not found.", path)
            };
        }
 
        public long GetLength(string path)
        {
            return GetEntry(path) is VfsFile entry ? entry.Size : 0;
        }
 
        public int GetBooleanAttributes(string path)
        {
            const int BA_EXISTS = 0x01;
            const int BA_REGULAR = 0x02;
            const int BA_DIRECTORY = 0x04;
 
            return GetEntry(path) switch
            {
                VfsDirectory => BA_EXISTS | BA_DIRECTORY,
                VfsFile => BA_EXISTS | BA_REGULAR,
                _ => 0,
            };
        }
 
        public static string GetAssemblyClassesPath(VfsContext context, Assembly assembly, string ikvmHome)
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            if (assembly is null)
                throw new ArgumentNullException(nameof(assembly));
 
            if (Directory.Exists(ikvmHome) == false)
                throw new DirectoryNotFoundException("Could not locate IkvmHome when finding VFS.");
 
            return PathExtensions.EnsureEndingDirectorySeparator(Path.Combine(ikvmHome, "assembly", GetAssemblyDirectoryName(context, assembly), "classes"));
#endif
        }
 
        public static string GetAssemblyResourcesPath(VfsContext context, Assembly assembly, string ikvmHome)
        {
#if FIRST_PASS || IMPORTER || EXPORTER
            throw new NotImplementedException();
#else
            if (assembly is null)
                throw new ArgumentNullException(nameof(assembly));
 
            if (Directory.Exists(ikvmHome) == false)
                throw new DirectoryNotFoundException("Could not locate IkvmHome when finding VFS.");
 
            return PathExtensions.EnsureEndingDirectorySeparator(Path.Combine(ikvmHome, "assembly", GetAssemblyDirectoryName(context, assembly), "resources"));
#endif
        }
 
        static bool IsLoadableAssembly(VfsContext context, Assembly assembly)
        {
            if (assembly.ReflectionOnly)
                return false;
 
#if NETFRAMEWORK
            if (assembly.GlobalAssemblyCache)
                return true;
#endif
 
            if (assembly.IsDynamic || assembly.Location == "")
                return false;
 
#if NETFRAMEWORK
            // optimization for the common case where the assembly was loaded from the base directory
            if (Path.GetDirectoryName(assembly.Location) == Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory))
                return true;
#endif
 
            // attempt to load the assembly from the context
            if (context.GetAssembly(assembly.GetName()) != null)
                return true;
 
            return false;
        }
 
        public static string GetAssemblyDirectoryName(VfsContext context, Assembly assembly)
        {
            // if we can't load the assembly by name, then use the MVID as the directory
            if (IsLoadableAssembly(context, assembly) == false)
                return assembly.ManifestModule.ModuleVersionId.ToString("N");
 
            var name = assembly.GetName();
            var simpleName = name.Name;
            var path = new ValueStringBuilder(simpleName.Length + 4);
            for (var i = 0; i < simpleName.Length; i++)
            {
                if (simpleName[i] == '_')
                    path.Append("_!");
                else
                    path.Append(simpleName[i]);
            }
 
            var publicKeyToken = name.GetPublicKeyToken();
            if (publicKeyToken != null && publicKeyToken.Length != 0)
            {
                var v = name.Version.ToString();
                path.EnsureCapacity(2 + v.Length + 2 + publicKeyToken.Length * 2);
 
                path.Append("__");
                path.Append(v);
                path.Append("__");
                for (int i = 0; i < publicKeyToken.Length; i++)
                    path.Append(string.Format("{0:x2}", publicKeyToken[i]));
            }
 
            if (name.CultureInfo != null && !string.IsNullOrEmpty(name.CultureInfo.Name))
            {
                var n = name.CultureInfo.Name;
                path.EnsureCapacity(2 + n.Length);
                path.Append("__");
                path.Append(name.CultureInfo.Name);
            }
 
            return path.ToString();
        }
 
    }
 
}