1use alloc::vec;
2
3use bytemuck::cast_vec;
4
5use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10 FileOpenOptions, RuntimeClassProto, RuntimeContext,
11 classes::java::{
12 io::{File, FileDescriptor},
13 lang::String,
14 },
15};
16
17pub struct RandomAccessFile;
19
20impl RandomAccessFile {
21 pub fn as_proto() -> RuntimeClassProto {
22 RuntimeClassProto {
23 name: "java/io/RandomAccessFile",
24 parent_class: Some("java/lang/Object"),
25 interfaces: vec!["java/io/DataInput", "java/io/DataOutput"],
26 methods: vec![
27 JavaMethodProto::new("<init>", "(Ljava/lang/String;Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new(
29 "<init>",
30 "(Ljava/io/File;Ljava/lang/String;)V",
31 Self::init_with_file,
32 MethodAccessFlags::PUBLIC,
33 ),
34 JavaMethodProto::new("read", "([B)I", Self::read, MethodAccessFlags::PUBLIC),
35 JavaMethodProto::new("read", "([BII)I", Self::read_offset_length, MethodAccessFlags::PUBLIC),
36 JavaMethodProto::new("write", "([B)V", Self::write, MethodAccessFlags::PUBLIC),
37 JavaMethodProto::new("write", "([BII)V", Self::write_offset_length, MethodAccessFlags::PUBLIC),
38 JavaMethodProto::new("length", "()J", Self::length, MethodAccessFlags::PUBLIC),
39 JavaMethodProto::new("getFilePointer", "()J", Self::get_file_pointer, MethodAccessFlags::PUBLIC),
40 JavaMethodProto::new(
41 "getFD",
42 "()Ljava/io/FileDescriptor;",
43 Self::get_fd,
44 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
45 ),
46 JavaMethodProto::new("seek", "(J)V", Self::seek, MethodAccessFlags::PUBLIC),
47 JavaMethodProto::new("setLength", "(J)V", Self::set_length, MethodAccessFlags::PUBLIC),
48 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
49 ],
50 fields: vec![JavaFieldProto::new(
51 "fd",
52 "Ljava/io/FileDescriptor;",
53 FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL,
54 )],
55 access_flags: ClassAccessFlags::PUBLIC,
56 }
57 }
58
59 async fn init(
60 jvm: &Jvm,
61 context: &mut RuntimeContext,
62 mut this: ClassInstanceRef<Self>,
63 name: ClassInstanceRef<String>,
64 mode: ClassInstanceRef<String>,
65 ) -> Result<()> {
66 tracing::debug!("java.io.RandomAccessFile::<init>({this:?}, {name:?}, {mode:?})");
67 if name.is_null() || mode.is_null() {
68 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
69 }
70
71 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
72
73 let name = JavaLangString::to_rust_string(jvm, &name).await?;
74 let mode = JavaLangString::to_rust_string(jvm, &mode).await?;
75
76 let write = mode.contains('w');
77
78 let fd_id = context
79 .open(
80 &name,
81 FileOpenOptions {
82 read: true,
83 write,
84 create: write,
85 ..Default::default()
86 },
87 )
88 .await;
89 if fd_id.is_err() {
90 return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await);
91 }
92 let fd = FileDescriptor::from_fd(jvm, fd_id.unwrap()).await?;
93 jvm.put_field(&mut this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;", fd)
94 .await?;
95
96 Ok(())
97 }
98
99 async fn init_with_file(
100 jvm: &Jvm,
101 _context: &mut RuntimeContext,
102 this: ClassInstanceRef<Self>,
103 file: ClassInstanceRef<File>,
104 mode: ClassInstanceRef<String>,
105 ) -> Result<()> {
106 tracing::debug!("java.io.RandomAccessFile::<init>({this:?}, {file:?}, {mode:?})");
107 if file.is_null() {
108 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
109 }
110
111 let name: ClassInstanceRef<String> = jvm.invoke_virtual(&file, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
112
113 let _: () = jvm
114 .invoke_special(
115 &this,
116 "java/io/RandomAccessFile",
117 "<init>",
118 "(Ljava/lang/String;Ljava/lang/String;)V",
119 (name, mode),
120 )
121 .await?;
122
123 Ok(())
124 }
125
126 async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<i8>>) -> Result<i32> {
127 tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?})");
128 if buf.is_null() {
129 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
130 }
131
132 let length = jvm.array_length(&buf).await?;
133 let read = jvm
134 .invoke_virtual(&this, "java/io/RandomAccessFile", "read", "([BII)I", (buf, 0, length as i32))
135 .await?;
136
137 Ok(read)
138 }
139
140 async fn read_offset_length(
141 jvm: &Jvm,
142 context: &mut RuntimeContext,
143 this: ClassInstanceRef<Self>,
144 mut buf: ClassInstanceRef<Array<i8>>,
145 offset: i32,
146 length: i32,
147 ) -> Result<i32> {
148 tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?}, {offset:?}, {length:?})");
149 if buf.is_null() {
150 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
151 }
152
153 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
154 let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
155
156 let mut rust_buf = vec![0; length as usize];
157 let Ok(read) = rust_file.read(&mut rust_buf).await else {
158 return Err(jvm.exception("java/io/IOException", "I/O error").await);
159 };
160
161 jvm.array_raw_buffer_mut(&mut buf).await?.write(offset as _, &rust_buf)?;
162
163 Ok(read as i32)
164 }
165
166 async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<i8>>) -> Result<()> {
167 tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?})");
168 if buf.is_null() {
169 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
170 }
171
172 let length = jvm.array_length(&buf).await?;
173 let _: () = jvm
174 .invoke_virtual(&this, "java/io/RandomAccessFile", "write", "([BII)V", (buf, 0, length as i32))
175 .await?;
176
177 Ok(())
178 }
179
180 async fn write_offset_length(
181 jvm: &Jvm,
182 context: &mut RuntimeContext,
183 this: ClassInstanceRef<Self>,
184 buf: ClassInstanceRef<Array<i8>>,
185 offset: i32,
186 length: i32,
187 ) -> Result<()> {
188 tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?}, {offset:?}, {length:?})");
189 if buf.is_null() {
190 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
191 }
192
193 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
194 let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
195
196 let mut rust_buf = vec![0; length as usize];
197 jvm.array_raw_buffer(&buf).await?.read(offset as _, &mut rust_buf)?;
198 let rust_buf = cast_vec(rust_buf);
199 let mut written = 0;
200 while written < rust_buf.len() {
201 match rust_file.write(&rust_buf[written..]).await {
202 Ok(0) | Err(_) => return Err(jvm.exception("java/io/IOException", "I/O error").await),
203 Ok(length) if length > rust_buf.len() - written => return Err(jvm.exception("java/io/IOException", "I/O error").await),
204 Ok(length) => written += length,
205 }
206 }
207
208 Ok(())
209 }
210
211 async fn seek(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, pos: i64) -> Result<()> {
212 tracing::debug!("java.io.RandomAccessFile::seek({this:?}, {pos:?})");
213
214 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
215 let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
216
217 if rust_file.seek(pos as _).await.is_err() {
218 return Err(jvm.exception("java/io/IOException", "I/O error").await);
219 }
220
221 Ok(())
222 }
223
224 async fn set_length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, new_length: i64) -> Result<()> {
225 tracing::debug!("java.io.RandomAccessFile::setLength({this:?}, {new_length:?})");
226
227 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
228 let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
229
230 if rust_file.set_len(new_length as _).await.is_err() {
231 return Err(jvm.exception("java/io/IOException", "I/O error").await);
232 }
233
234 Ok(())
235 }
236
237 async fn length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
238 tracing::debug!("java.io.RandomAccessFile::length({this:?})");
239
240 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
241 let rust_file = FileDescriptor::file(jvm, context, fd).await?;
242
243 let Ok(metadata) = rust_file.metadata().await else {
244 return Err(jvm.exception("java/io/IOException", "I/O error").await);
245 };
246 let len = metadata.size;
247
248 Ok(len as i64)
249 }
250
251 async fn get_file_pointer(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
252 tracing::debug!("java.io.RandomAccessFile::getFilePointer({this:?})");
253
254 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
255 let rust_file = FileDescriptor::file(jvm, context, fd).await?;
256
257 let Ok(pos) = rust_file.tell().await else {
258 return Err(jvm.exception("java/io/IOException", "I/O error").await);
259 };
260
261 Ok(pos as i64)
262 }
263
264 async fn get_fd(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<File>> {
265 tracing::debug!("java.io.RandomAccessFile::getFD({this:?})");
266
267 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
268
269 Ok(fd)
270 }
271
272 async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
273 tracing::debug!("java.io.RandomAccessFile::close({this:?})");
274
275 let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
276 FileDescriptor::close(jvm, context, fd).await?;
277
278 Ok(())
279 }
280}