Skip to main content

rustjava_runtime/classes/java/util/zip/
zip_file.rs

1use alloc::{string::ToString, vec, vec::Vec};
2use core::iter;
3
4// XXX for zip..
5extern crate std;
6use std::io::{Cursor, Read};
7
8use zip::ZipArchive;
9
10use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
11use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
12use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
13
14use crate::{
15    RuntimeClassProto, RuntimeContext,
16    classes::java::{
17        io::{File, InputStream},
18        lang::String,
19        util::{Enumeration, zip::ZipEntry},
20    },
21};
22
23// class java.util.zip.ZipFile
24pub struct ZipFile;
25
26impl ZipFile {
27    pub fn as_proto() -> RuntimeClassProto {
28        RuntimeClassProto {
29            name: "java/util/zip/ZipFile",
30            parent_class: Some("java/lang/Object"),
31            interfaces: vec![],
32            methods: vec![
33                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new(
35                    "getEntry",
36                    "(Ljava/lang/String;)Ljava/util/zip/ZipEntry;",
37                    Self::get_entry,
38                    MethodAccessFlags::PUBLIC,
39                ),
40                JavaMethodProto::new(
41                    "getInputStream",
42                    "(Ljava/util/zip/ZipEntry;)Ljava/io/InputStream;",
43                    Self::get_input_stream,
44                    MethodAccessFlags::PUBLIC,
45                ),
46                JavaMethodProto::new("entries", "()Ljava/util/Enumeration;", Self::entries, MethodAccessFlags::PUBLIC),
47            ],
48            fields: vec![JavaFieldProto::new("zipData", "[B", FieldAccessFlags::PRIVATE)],
49            access_flags: ClassAccessFlags::PUBLIC,
50        }
51    }
52
53    pub(crate) async fn get_zip_archive(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ZipArchive<Cursor<Vec<u8>>>> {
54        let zip_data: ClassInstanceRef<Array<i8>> = jvm.get_field(this, "java/util/zip/ZipFile", "zipData", "[B").await?;
55        let length = jvm.array_length(&zip_data).await?;
56        let mut buf = vec![0u8; length];
57        jvm.array_raw_buffer(&zip_data).await?.read(0, &mut buf)?;
58
59        match ZipArchive::new(Cursor::new(buf)) {
60            Ok(x) => Ok(x),
61            Err(err) => Err(jvm.exception("java/util/zip/ZipException", &err.to_string()).await),
62        }
63    }
64
65    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
66        tracing::debug!("java.util.zip.ZipFile::<init>({this:?}, {file:?})");
67
68        if file.is_null() {
69            return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
70        }
71
72        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
73
74        let length: i64 = jvm.invoke_virtual(&file, "java/io/File", "length", "()J", ()).await?;
75        let is = jvm.new_class("java/io/FileInputStream", "(Ljava/io/File;)V", (file,)).await?;
76
77        let buf = jvm.instantiate_array("B", length as _).await?;
78        let _: i32 = jvm.invoke_virtual(&is, "java/io/InputStream", "read", "([B)I", (buf.clone(),)).await?;
79
80        jvm.put_field(&mut this, "java/util/zip/ZipFile", "zipData", "[B", buf).await?;
81
82        // the constructor throws ZipException for a malformed archive
83        let _ = Self::get_zip_archive(jvm, &this).await?;
84
85        Ok(())
86    }
87
88    async fn get_entry(
89        jvm: &Jvm,
90        _: &mut RuntimeContext,
91        this: ClassInstanceRef<Self>,
92        name: ClassInstanceRef<String>,
93    ) -> Result<ClassInstanceRef<ZipEntry>> {
94        tracing::debug!("java.util.zip.ZipFile::getEntry({this:?}, {name:?})");
95
96        let entry = jvm.new_class("java/util/zip/ZipEntry", "(Ljava/lang/String;)V", (name.clone(),)).await?;
97        let name = JavaLangString::to_rust_string(jvm, &name).await?;
98
99        let mut zip = Self::get_zip_archive(jvm, &this).await?;
100        let file_size = zip.by_name(&name).map(|x| x.size());
101
102        if let Ok(x) = file_size {
103            let _: () = jvm
104                .invoke_virtual(&entry, "java/util/zip/ZipEntry", "setSize", "(J)V", (x as i64,))
105                .await?;
106
107            Ok(entry.into())
108        } else {
109            Ok(None.into())
110        }
111    }
112
113    async fn entries(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Enumeration>> {
114        tracing::debug!("java.util.zip.ZipFile::entries({this:?})");
115
116        let zip = Self::get_zip_archive(jvm, &this).await?;
117        let names = match zip.file_names().collect::<core::result::Result<Vec<_>, _>>() {
118            Ok(names) => names,
119            Err(err) => return Err(jvm.exception("java/util/zip/ZipException", &err.to_string()).await),
120        };
121
122        let mut name_array = jvm.instantiate_array("Ljava/lang/String;", names.len() as _).await?;
123        for (i, name) in names.iter().enumerate() {
124            let name = JavaLangString::from_rust_string(jvm, name).await?;
125            jvm.store_array(&mut name_array, i as _, iter::once(name)).await?;
126        }
127
128        let entries = jvm
129            .new_class(
130                "java/util/zip/ZipFile$Entries",
131                "(Ljava/util/zip/ZipFile;[Ljava/lang/String;)V",
132                (this, name_array),
133            )
134            .await?;
135
136        Ok(entries.into())
137    }
138
139    async fn get_input_stream(
140        jvm: &Jvm,
141        _: &mut RuntimeContext,
142        this: ClassInstanceRef<Self>,
143        entry: ClassInstanceRef<ZipEntry>,
144    ) -> Result<ClassInstanceRef<InputStream>> {
145        tracing::debug!("java.util.zip.ZipFile::getInputStream({this:?}, {entry:?})");
146
147        if entry.is_null() {
148            return Err(jvm.exception("java/lang/NullPointerException", "entry is null").await);
149        }
150
151        let entry_name = jvm
152            .invoke_virtual(&entry, "java/util/zip/ZipEntry", "getName", "()Ljava/lang/String;", ())
153            .await?;
154        let entry_name = JavaLangString::to_rust_string(jvm, &entry_name).await?;
155
156        let data = {
157            let mut zip = Self::get_zip_archive(jvm, &this).await?;
158            let file = zip.by_name(&entry_name);
159            let Ok(mut file) = file else {
160                // getInputStream returns null when the entry is not in this zip
161                return Ok(None.into());
162            };
163
164            let mut buf = Vec::new();
165            file.read_to_end(&mut buf).map(|_| buf)
166        };
167        let Ok(data) = data else {
168            return Err(jvm.exception("java/util/zip/ZipException", "invalid entry data").await);
169        };
170
171        // TODO do we have to use InflaterInputStream?
172        let mut java_buf = jvm.instantiate_array("B", data.len() as _).await?;
173        jvm.array_raw_buffer_mut(&mut java_buf).await?.write(0, &data)?;
174
175        let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (java_buf,)).await?;
176
177        Ok(input_stream.into())
178    }
179}