Skip to main content

rustjava_runtime/classes/java/util/jar/
jar_file.rs

1use alloc::{string::ToString, vec};
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::{File, InputStream},
11        lang::String,
12        util::{
13            Enumeration,
14            jar::{JarEntry, Manifest},
15            zip::{ZipEntry, ZipFile},
16        },
17    },
18};
19
20// class java.util.jar.JarFile
21pub struct JarFile;
22
23impl JarFile {
24    pub fn as_proto() -> RuntimeClassProto {
25        RuntimeClassProto {
26            name: "java/util/jar/JarFile",
27            parent_class: Some("java/util/zip/ZipFile"),
28            interfaces: vec![],
29            methods: vec![
30                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_string, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new(
33                    "getJarEntry",
34                    "(Ljava/lang/String;)Ljava/util/jar/JarEntry;",
35                    Self::get_jar_entry,
36                    MethodAccessFlags::PUBLIC,
37                ),
38                JavaMethodProto::new("entries", "()Ljava/util/Enumeration;", Self::entries, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("getManifest", "()Ljava/util/jar/Manifest;", Self::get_manifest, MethodAccessFlags::PUBLIC),
40            ],
41            fields: vec![],
42            access_flags: ClassAccessFlags::PUBLIC,
43        }
44    }
45
46    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
47        tracing::debug!("java.util.jar.JarFile::<init>({this:?}, {file:?})");
48
49        let _: () = jvm
50            .invoke_special(&this, "java/util/zip/ZipFile", "<init>", "(Ljava/io/File;)V", (file,))
51            .await?;
52
53        Ok(())
54    }
55
56    async fn init_with_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, name: ClassInstanceRef<String>) -> Result<()> {
57        tracing::debug!("java.util.jar.JarFile::<init>({this:?}, {name:?})");
58
59        let file = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (name,)).await?;
60
61        let _: () = jvm
62            .invoke_special(&this, "java/util/jar/JarFile", "<init>", "(Ljava/io/File;)V", (file,))
63            .await?;
64
65        Ok(())
66    }
67
68    async fn get_jar_entry(
69        jvm: &Jvm,
70        _: &mut RuntimeContext,
71        this: ClassInstanceRef<Self>,
72        name: ClassInstanceRef<String>,
73    ) -> Result<ClassInstanceRef<JarEntry>> {
74        tracing::debug!("java.util.jar.JarFile::getJarEntry({this:?}, {name:?})");
75
76        let zip_entry: ClassInstanceRef<ZipEntry> = jvm
77            .invoke_virtual(
78                &this,
79                "java/util/jar/JarFile",
80                "getEntry",
81                "(Ljava/lang/String;)Ljava/util/zip/ZipEntry;",
82                (name,),
83            )
84            .await?;
85
86        if zip_entry.is_null() {
87            return Ok(None.into());
88        }
89
90        let jar_entry = jvm
91            .new_class("java/util/jar/JarEntry", "(Ljava/util/zip/ZipEntry;)V", (zip_entry,))
92            .await?;
93
94        Ok(jar_entry.into())
95    }
96
97    async fn entries(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Enumeration>> {
98        tracing::debug!("java.util.jar.JarFile::entries({this:?})");
99
100        let zip_entries: ClassInstanceRef<Enumeration> = jvm
101            .invoke_special(&this, "java/util/zip/ZipFile", "entries", "()Ljava/util/Enumeration;", ())
102            .await?;
103
104        let entries = jvm
105            .new_class("java/util/jar/JarFile$Entries", "(Ljava/util/zip/ZipFile$Entries;)V", (zip_entries,))
106            .await?;
107
108        Ok(entries.into())
109    }
110
111    async fn get_manifest(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Manifest>> {
112        tracing::debug!("java.util.jar.JarFile::getManifest({this:?})");
113
114        let manifest_name = JavaLangString::from_rust_string(jvm, "META-INF/MANIFEST.MF").await?;
115        let mut manifest_file: ClassInstanceRef<JarEntry> = jvm
116            .invoke_virtual(
117                &this,
118                "java/util/jar/JarFile",
119                "getJarEntry",
120                "(Ljava/lang/String;)Ljava/util/jar/JarEntry;",
121                (manifest_name,),
122            )
123            .await?;
124
125        if manifest_file.is_null() {
126            let name = {
127                let zip = ZipFile::get_zip_archive(jvm, &ClassInstanceRef::from(this.instance.clone())).await?;
128                let mut manifest_name = None;
129                for name in zip.file_names() {
130                    let name = match name {
131                        Ok(name) => name,
132                        Err(err) => return Err(jvm.exception("java/util/zip/ZipException", &err.to_string()).await),
133                    };
134                    if name.eq_ignore_ascii_case("META-INF/MANIFEST.MF") {
135                        manifest_name = Some(name.into_owned());
136                        break;
137                    }
138                }
139                manifest_name
140            };
141            let Some(name) = name else {
142                return Ok(None.into());
143            };
144            let name = JavaLangString::from_rust_string(jvm, &name).await?;
145            manifest_file = jvm
146                .invoke_virtual(
147                    &this,
148                    "java/util/jar/JarFile",
149                    "getJarEntry",
150                    "(Ljava/lang/String;)Ljava/util/jar/JarEntry;",
151                    (name,),
152                )
153                .await?;
154        }
155
156        let input_stream: ClassInstanceRef<InputStream> = jvm
157            .invoke_virtual(
158                &this,
159                "java/util/jar/JarFile",
160                "getInputStream",
161                "(Ljava/util/zip/ZipEntry;)Ljava/io/InputStream;",
162                (manifest_file,),
163            )
164            .await?;
165
166        let manifest = jvm
167            .new_class("java/util/jar/Manifest", "(Ljava/io/InputStream;)V", (input_stream,))
168            .await?;
169
170        Ok(manifest.into())
171    }
172}