rustjava_runtime/classes/java/util/zip/
zip_file.rs1use alloc::{boxed::Box, string::ToString, vec, vec::Vec};
2use core::iter;
3
4extern crate std;
6use std::io::{self, Read, Seek, SeekFrom};
7
8use zip::ZipArchive;
9
10use jvm::{Array, ArrayRawBuffer, 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
23pub 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<ZipDataReader>> {
54 let zip_data: ClassInstanceRef<Array<i8>> = jvm.get_field(this, "java/util/zip/ZipFile", "zipData", "[B").await?;
55 let reader = ZipDataReader {
56 length: jvm.array_length(&zip_data).await? as u64,
57 buffer: jvm.array_raw_buffer(&zip_data).await?,
58 position: 0,
59 };
60
61 match ZipArchive::new(reader) {
62 Ok(x) => Ok(x),
63 Err(err) => Err(jvm.exception("java/util/zip/ZipException", &err.to_string()).await),
64 }
65 }
66
67 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
68 tracing::debug!("java.util.zip.ZipFile::<init>({this:?}, {file:?})");
69
70 if file.is_null() {
71 return Err(jvm.exception("java/lang/NullPointerException", "file is null").await);
72 }
73
74 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
75
76 let length: i64 = jvm.invoke_virtual(&file, "java/io/File", "length", "()J", ()).await?;
77 let is = jvm.new_class("java/io/FileInputStream", "(Ljava/io/File;)V", (file,)).await?;
78
79 let buf = jvm.instantiate_array("B", length as _).await?;
80 let _: i32 = jvm.invoke_virtual(&is, "java/io/InputStream", "read", "([B)I", (buf.clone(),)).await?;
81
82 jvm.put_field(&mut this, "java/util/zip/ZipFile", "zipData", "[B", buf).await?;
83
84 let _ = Self::get_zip_archive(jvm, &this).await?;
86
87 Ok(())
88 }
89
90 async fn get_entry(
91 jvm: &Jvm,
92 _: &mut RuntimeContext,
93 this: ClassInstanceRef<Self>,
94 name: ClassInstanceRef<String>,
95 ) -> Result<ClassInstanceRef<ZipEntry>> {
96 tracing::debug!("java.util.zip.ZipFile::getEntry({this:?}, {name:?})");
97
98 let entry = jvm.new_class("java/util/zip/ZipEntry", "(Ljava/lang/String;)V", (name.clone(),)).await?;
99 let name = JavaLangString::to_rust_string(jvm, &name).await?;
100
101 let mut zip = Self::get_zip_archive(jvm, &this).await?;
102 let file_size = zip.by_name(&name).map(|x| x.size());
103
104 if let Ok(x) = file_size {
105 let _: () = jvm
106 .invoke_virtual(&entry, "java/util/zip/ZipEntry", "setSize", "(J)V", (x as i64,))
107 .await?;
108
109 Ok(entry.into())
110 } else {
111 Ok(None.into())
112 }
113 }
114
115 async fn entries(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Enumeration>> {
116 tracing::debug!("java.util.zip.ZipFile::entries({this:?})");
117
118 let zip = Self::get_zip_archive(jvm, &this).await?;
119 let names = match zip.file_names().collect::<core::result::Result<Vec<_>, _>>() {
120 Ok(names) => names,
121 Err(err) => return Err(jvm.exception("java/util/zip/ZipException", &err.to_string()).await),
122 };
123
124 let mut name_array = jvm.instantiate_array("Ljava/lang/String;", names.len() as _).await?;
125 for (i, name) in names.iter().enumerate() {
126 let name = JavaLangString::from_rust_string(jvm, name).await?;
127 jvm.store_array(&mut name_array, i as _, iter::once(name)).await?;
128 }
129
130 let entries = jvm
131 .new_class(
132 "java/util/zip/ZipFile$Entries",
133 "(Ljava/util/zip/ZipFile;[Ljava/lang/String;)V",
134 (this, name_array),
135 )
136 .await?;
137
138 Ok(entries.into())
139 }
140
141 async fn get_input_stream(
142 jvm: &Jvm,
143 _: &mut RuntimeContext,
144 this: ClassInstanceRef<Self>,
145 entry: ClassInstanceRef<ZipEntry>,
146 ) -> Result<ClassInstanceRef<InputStream>> {
147 tracing::debug!("java.util.zip.ZipFile::getInputStream({this:?}, {entry:?})");
148
149 if entry.is_null() {
150 return Err(jvm.exception("java/lang/NullPointerException", "entry is null").await);
151 }
152
153 let entry_name = jvm
154 .invoke_virtual(&entry, "java/util/zip/ZipEntry", "getName", "()Ljava/lang/String;", ())
155 .await?;
156 let entry_name = JavaLangString::to_rust_string(jvm, &entry_name).await?;
157
158 let data = {
159 let mut zip = Self::get_zip_archive(jvm, &this).await?;
160 let file = zip.by_name(&entry_name);
161 let Ok(mut file) = file else {
162 return Ok(None.into());
164 };
165
166 let mut buf = Vec::new();
167 file.read_to_end(&mut buf).map(|_| buf)
168 };
169 let Ok(data) = data else {
170 return Err(jvm.exception("java/util/zip/ZipException", "invalid entry data").await);
171 };
172
173 let mut java_buf = jvm.instantiate_array("B", data.len() as _).await?;
175 jvm.array_raw_buffer_mut(&mut java_buf).await?.write(0, &data)?;
176
177 let input_stream = jvm.new_class("java/io/ByteArrayInputStream", "([B)V", (java_buf,)).await?;
178
179 Ok(input_stream.into())
180 }
181}
182
183pub(crate) struct ZipDataReader {
186 buffer: Box<dyn ArrayRawBuffer>,
187 length: u64,
188 position: u64,
189}
190
191impl Read for ZipDataReader {
192 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
193 let count = buf.len().min(self.length.saturating_sub(self.position) as usize);
194 if count == 0 {
196 return Ok(0);
197 }
198 self.buffer
199 .read(self.position as usize, &mut buf[..count])
200 .map_err(|_| io::Error::other("zip data read failed"))?;
201 self.position += count as u64;
202
203 Ok(count)
204 }
205}
206
207impl Seek for ZipDataReader {
208 fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
209 let position = match pos {
210 SeekFrom::Start(offset) => Some(offset),
211 SeekFrom::End(offset) => self.length.checked_add_signed(offset),
212 SeekFrom::Current(offset) => self.position.checked_add_signed(offset),
213 };
214 self.position = position.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "seek before start of zip data"))?;
215
216 Ok(self.position)
217 }
218}