JarFile.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Threading;
 
using IKVM.CoreLib.Modules;
 
namespace IKVM.CoreLib.Jar
{
 
    internal class JarFile : IDisposable
    {
 
        const string META_INF = "META-INF/";
        const string META_INF_VERSIONS = META_INF + "versions/";
        const string MANIFEST_NAME = META_INF + "MANIFEST.MF";
        const string INDEX_NAME = "META-INF/INDEX.LIST";
 
        internal static readonly RuntimeVersion BASE_VERSION = RuntimeVersion.Parse("8");
        internal static readonly int BASE_VERSION_FEATURE = BASE_VERSION.Feature;
        internal static readonly RuntimeVersion RUNTIME_VERSION = RuntimeVersion.Parse("8");
        internal static readonly bool MULTI_RELEASE_ENABLED = false;
        internal static readonly bool MULTI_RELEASE_FORCED = false;
 
        readonly ZipArchive _archive;
        readonly RuntimeVersion _version;
        readonly int _versionFeature;
        readonly bool _dispose;
 
        Manifest? _manifest;
        bool _hasCheckedSpecialAttributes;
        bool _hasClassPathAttribute;
        bool _isMultiRelease;
 
        public JarFile(ZipArchive archive, bool dispose = false) :
            this(archive, RUNTIME_VERSION, dispose)
        {
 
        }
 
        public JarFile(ZipArchive archive, RuntimeVersion version, bool dispose = false)
        {
            _archive = archive ?? throw new ArgumentNullException(nameof(archive));
            _dispose = dispose;
 
            if (MULTI_RELEASE_FORCED || version.Feature == RUNTIME_VERSION.Feature)
            {
                _version = RUNTIME_VERSION;
            }
            else if (version.Feature <= BASE_VERSION_FEATURE)
            {
                _version = BASE_VERSION;
            }
            else
            {
                _version = RuntimeVersion.Parse(version.Feature.ToString());
            }
 
            _versionFeature = _version.Feature;
        }
 
        public JarFile(Stream stream, bool dispose = true) :
            this(stream, RUNTIME_VERSION, dispose)
        {
 
        }
 
        public JarFile(Stream stream, RuntimeVersion releaseVersion, bool dispose = true) :
            this(new ZipArchive(stream, ZipArchiveMode.Read, dispose), releaseVersion, dispose)
        {
 
        }
 
        public JarFile(string path) :
            this(path, RUNTIME_VERSION)
        {
 
        }
 
        public JarFile(string path, RuntimeVersion releaseVersion) :
            this(File.OpenRead(path), releaseVersion, true)
        {
 
        }
 
        public RuntimeVersion Version => IsMultiRelease ? _version : BASE_VERSION;
 
        public Manifest? Manifest => GetOrReadManifest();
 
        Manifest? GetOrReadManifest()
        {
            if (_manifest is null)
                Interlocked.CompareExchange(ref _manifest, ReadManifest(), null);
 
            return _manifest;
        }
 
        Manifest? ReadManifest()
        {
            // find the manifest in the archive
            var e = _archive.GetEntry(MANIFEST_NAME);
            if (e == null)
                return null;
 
            // open and read the manifest
            using var s = e.Open();
            return new Manifest(s);
        }
 
        void CheckForSpecialAttributes()
        {
            if (_hasCheckedSpecialAttributes)
                return;
 
            if (Manifest is not null)
            {
                if (Manifest.MainAttributes.TryGetValue("Class-Path", out _))
                    _hasClassPathAttribute = true;
 
                if (Manifest.MainAttributes.TryGetValue("Multi-Release", out var s))
                    _isMultiRelease = bool.Parse(s);
            }
 
            _hasCheckedSpecialAttributes = true;
        }
 
        public bool HasClassPathAttribute
        {
            get
            {
                if (_hasClassPathAttribute)
                    return true;
 
                CheckForSpecialAttributes();
                return _hasClassPathAttribute;
            }
        }
 
        public bool IsMultiRelease
        {
            get
            {
                if (_isMultiRelease)
                    return true;
 
                CheckForSpecialAttributes();
                return _isMultiRelease;
            }
        }
 
        public IEnumerable<JarFileEntry> GetEntries()
        {
            var hs = new HashSet<string>();
 
            foreach (var entry in _archive.Entries)
            {
                var bn = GetBaseName(entry.FullName);
                if (bn is null)
                    continue;
 
                if (hs.Add(bn))
                {
                    var je = GetEntry(bn);
                    if (je is not null)
                        yield return je.Value;
                }
            }
        }
 
        string? GetBaseName(string name)
        {
            if (name.StartsWith(META_INF_VERSIONS))
            {
                int off = META_INF_VERSIONS.Length;
                int idx = name.IndexOf('/', off);
 
                // filter out dir META-INF/versions/ and META-INF/versions/*/
                // and any entry with version > 'version'
                if (idx == -1 || idx == (name.Length - 1) || (int.TryParse(name[off..idx], out var i) && i > _versionFeature))
                    return null;
 
                // map to its base name
                return name.Substring(idx + 1);
            }
 
            return name;
        }
 
        public JarFileEntry? GetEntry(string name)
        {
            if (IsMultiRelease)
            {
                var ve = GetVersionedEntry(name, null);
                if (ve is not null)
                    return ve;
            }
 
            var je = _archive.GetEntry(name);
            if (je is not null)
                return new JarFileEntry(this, je, name, _versionFeature);
 
            return null;
        }
 
        JarFileEntry? GetVersionedEntry(string name, JarFileEntry? defaultEntry)
        {
            if (BASE_VERSION_FEATURE < _versionFeature && name.StartsWith(META_INF) == false)
            {
                // start with version of JAR file itself
                var version = _versionFeature;
 
                // scan each version from JAR file version down to base version
                while (version >= BASE_VERSION_FEATURE)
                {
                    var entry = _archive.GetEntry(META_INF_VERSIONS + version + "/" + name);
                    if (entry != null)
                        return new JarFileEntry(this, entry, name, version);
 
                    version--;
                }
            }
 
            return defaultEntry;
        }
 
        public void Dispose()
        {
            if (_dispose && _archive != null)
                _archive.Dispose();
        }
 
    }
 
}