1use alloc::{format, vec};
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::{
10 io::InputStream,
11 lang::String,
12 net::{URLConnection, URLStreamHandler},
13 },
14};
15
16pub struct URL;
18
19impl URL {
20 pub fn as_proto() -> RuntimeClassProto {
21 RuntimeClassProto {
22 name: "java/net/URL",
23 parent_class: Some("java/lang/Object"),
24 interfaces: vec!["java/io/Serializable"],
25 methods: vec![
26 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_spec, MethodAccessFlags::PUBLIC),
27 JavaMethodProto::new(
28 "<init>",
29 "(Ljava/net/URL;Ljava/lang/String;)V",
30 Self::init_with_context_spec,
31 MethodAccessFlags::PUBLIC,
32 ),
33 JavaMethodProto::new(
34 "<init>",
35 "(Ljava/net/URL;Ljava/lang/String;Ljava/net/URLStreamHandler;)V",
36 Self::init_with_context_spec_handler,
37 MethodAccessFlags::PUBLIC,
38 ),
39 JavaMethodProto::new(
40 "<init>",
41 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
42 Self::init_with_protocol_host_file,
43 MethodAccessFlags::PUBLIC,
44 ),
45 JavaMethodProto::new(
46 "<init>",
47 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/net/URLStreamHandler;)V",
48 Self::init_with_protocol_host_port_file_handler,
49 MethodAccessFlags::PUBLIC,
50 ),
51 JavaMethodProto::new(
52 "openConnection",
53 "()Ljava/net/URLConnection;",
54 Self::open_connection,
55 MethodAccessFlags::PUBLIC,
56 ),
57 JavaMethodProto::new(
58 "openStream",
59 "()Ljava/io/InputStream;",
60 Self::open_stream,
61 MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
62 ),
63 JavaMethodProto::new(
64 "set",
65 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
66 Self::set,
67 MethodAccessFlags::PROTECTED,
68 ),
69 JavaMethodProto::new("getPort", "()I", Self::get_port, MethodAccessFlags::PUBLIC),
70 JavaMethodProto::new("getProtocol", "()Ljava/lang/String;", Self::get_protocol, MethodAccessFlags::PUBLIC),
71 JavaMethodProto::new("getHost", "()Ljava/lang/String;", Self::get_host, MethodAccessFlags::PUBLIC),
72 JavaMethodProto::new("getFile", "()Ljava/lang/String;", Self::get_file, MethodAccessFlags::PUBLIC),
73 ],
74 fields: vec![
75 JavaFieldProto::new("protocol", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
76 JavaFieldProto::new("host", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
77 JavaFieldProto::new("port", "I", FieldAccessFlags::PRIVATE),
78 JavaFieldProto::new("file", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
79 JavaFieldProto::new("handler", "Ljava/net/URLStreamHandler;", FieldAccessFlags::TRANSIENT),
80 ],
81 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
82 }
83 }
84
85 async fn init_with_spec(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, spec: ClassInstanceRef<String>) -> Result<()> {
86 tracing::debug!("java.net.URL::<init>({this:?}, {spec:?})");
87
88 let _: () = jvm
89 .invoke_special(&this, "java/net/URL", "<init>", "(Ljava/net/URL;Ljava/lang/String;)V", (None, spec))
90 .await?;
91
92 Ok(())
93 }
94
95 async fn init_with_context_spec(
96 jvm: &Jvm,
97 _: &mut RuntimeContext,
98 this: ClassInstanceRef<Self>,
99 context: ClassInstanceRef<URL>,
100 spec: ClassInstanceRef<String>,
101 ) -> Result<()> {
102 tracing::debug!("java.net.URL::<init>({this:?}, {context:?}, {spec:?})");
103
104 let _: () = jvm
105 .invoke_special(
106 &this,
107 "java/net/URL",
108 "<init>",
109 "(Ljava/net/URL;Ljava/lang/String;Ljava/net/URLStreamHandler;)V",
110 (context, spec, None),
111 )
112 .await?;
113
114 Ok(())
115 }
116
117 async fn init_with_context_spec_handler(
118 jvm: &Jvm,
119 _: &mut RuntimeContext,
120 mut this: ClassInstanceRef<Self>,
121 context: ClassInstanceRef<URL>,
122 spec: ClassInstanceRef<String>,
123 handler: ClassInstanceRef<URLStreamHandler>,
124 ) -> Result<()> {
125 tracing::debug!("java.net.URL::<init>({this:?}, {context:?}, {spec:?}, {handler:?})");
126
127 if spec.is_null() {
128 return Err(jvm.exception("java/net/MalformedURLException", "spec is null").await);
129 }
130
131 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
132
133 let spec_str = JavaLangString::to_rust_string(jvm, &spec).await?;
134
135 let protocol = spec_str.split(':').next().unwrap_or_default();
136
137 let handler = Self::get_handler(jvm, protocol).await?;
138
139 jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler.clone())
140 .await?;
141
142 let _: () = jvm
143 .invoke_virtual(
144 &handler,
145 "java/net/URLStreamHandler",
146 "parseURL",
147 "(Ljava/net/URL;Ljava/lang/String;II)V",
148 (this, spec, 0, spec_str.len() as i32),
149 )
150 .await?;
151
152 Ok(())
153 }
154
155 async fn init_with_protocol_host_file(
156 jvm: &Jvm,
157 _: &mut RuntimeContext,
158 this: ClassInstanceRef<Self>,
159 protocol: ClassInstanceRef<String>,
160 host: ClassInstanceRef<String>,
161 file: ClassInstanceRef<String>,
162 ) -> Result<()> {
163 tracing::debug!("java.net.URL::<init>({this:?}, {protocol:?}, {host:?}, {file:?})");
164
165 let _: () = jvm
166 .invoke_special(
167 &this,
168 "java/net/URL",
169 "<init>",
170 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/net/URLStreamHandler;)V",
171 (protocol, host, -1, file, None),
172 )
173 .await?;
174
175 Ok(())
176 }
177
178 #[allow(clippy::too_many_arguments)]
179 async fn init_with_protocol_host_port_file_handler(
180 jvm: &Jvm,
181 _: &mut RuntimeContext,
182 mut this: ClassInstanceRef<Self>,
183 protocol: ClassInstanceRef<String>,
184 host: ClassInstanceRef<String>,
185 port: i32,
186 file: ClassInstanceRef<String>,
187 handler: ClassInstanceRef<URLStreamHandler>,
188 ) -> Result<()> {
189 tracing::debug!("java.net.URL::<init>({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {handler:?})");
190
191 if protocol.is_null() || file.is_null() {
192 return Err(jvm.exception("java/lang/NullPointerException", "protocol or file is null").await);
193 }
194
195 let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
196
197 jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler.clone())
198 .await?;
199
200 let _: () = jvm
201 .invoke_virtual(
202 &this,
203 "java/net/URL",
204 "set",
205 "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V",
206 (protocol.clone(), host, port, file, None),
207 )
208 .await?;
209
210 if handler.is_null() {
211 let protocol = JavaLangString::to_rust_string(jvm, &protocol).await?;
212 let handler = Self::get_handler(jvm, &protocol).await?;
213
214 jvm.put_field(&mut this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;", handler)
215 .await?;
216 }
217
218 Ok(())
219 }
220
221 #[allow(clippy::too_many_arguments)]
222 async fn set(
223 jvm: &Jvm,
224 _: &mut RuntimeContext,
225 mut this: ClassInstanceRef<Self>,
226 protocol: ClassInstanceRef<String>,
227 host: ClassInstanceRef<String>,
228 port: i32,
229 file: ClassInstanceRef<String>,
230 r#ref: ClassInstanceRef<String>,
231 ) -> Result<()> {
232 tracing::debug!("java.net.URL::set({this:?}, {protocol:?}, {host:?}, {port:?}, {file:?}, {:?})", &r#ref);
233
234 jvm.put_field(&mut this, "java/net/URL", "protocol", "Ljava/lang/String;", protocol)
235 .await?;
236 jvm.put_field(&mut this, "java/net/URL", "host", "Ljava/lang/String;", host).await?;
237 jvm.put_field(&mut this, "java/net/URL", "port", "I", port).await?;
238 jvm.put_field(&mut this, "java/net/URL", "file", "Ljava/lang/String;", file).await?;
239
240 Ok(())
241 }
242
243 async fn open_connection(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<URLConnection>> {
244 tracing::debug!("java.net.URL::openConnection({this:?})");
245
246 let handler = jvm.get_field(&this, "java/net/URL", "handler", "Ljava/net/URLStreamHandler;").await?;
247 let connection = jvm
248 .invoke_virtual(
249 &handler,
250 "java/net/URLStreamHandler",
251 "openConnection",
252 "(Ljava/net/URL;)Ljava/net/URLConnection;",
253 (this,),
254 )
255 .await?;
256
257 Ok(connection)
258 }
259
260 async fn open_stream(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<InputStream>> {
261 tracing::debug!("java.net.URL::openStream({this:?})");
262
263 let connection = jvm
264 .invoke_virtual(&this, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
265 .await?;
266
267 let stream = jvm
268 .invoke_virtual(&connection, "java/net/URLConnection", "getInputStream", "()Ljava/io/InputStream;", ())
269 .await?;
270
271 Ok(stream)
272 }
273
274 async fn get_port(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
275 tracing::debug!("java.net.URL::getPort({this:?})");
276
277 let port = jvm.get_field(&this, "java/net/URL", "port", "I").await?;
278
279 Ok(port)
280 }
281
282 async fn get_protocol(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
283 tracing::debug!("java.net.URL::getProtocol({this:?})");
284
285 let protocol = jvm.get_field(&this, "java/net/URL", "protocol", "Ljava/lang/String;").await?;
286
287 Ok(protocol)
288 }
289
290 async fn get_host(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
291 tracing::debug!("java.net.URL::getHost({this:?})");
292
293 let host = jvm.get_field(&this, "java/net/URL", "host", "Ljava/lang/String;").await?;
294
295 Ok(host)
296 }
297
298 async fn get_file(jvm: &Jvm, _runtime: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
299 tracing::debug!("java.net.URL::getFile({this:?})");
300
301 let file = jvm.get_field(&this, "java/net/URL", "file", "Ljava/lang/String;").await?;
302
303 Ok(file)
304 }
305
306 async fn get_handler(jvm: &Jvm, protocol: &str) -> Result<ClassInstanceRef<URLStreamHandler>> {
307 if protocol == "file" {
308 Ok(jvm.new_class("org/rustjava/net/FileURLHandler", "()V", ()).await?.into())
309 } else if protocol == "jar" {
310 Ok(jvm.new_class("org/rustjava/net/JarURLHandler", "()V", ()).await?.into())
311 } else {
312 Err(jvm
313 .exception("java/net/MalformedURLException", &format!("unknown protocol: {protocol}"))
314 .await)
315 }
316 }
317}