rustjava_runtime/classes/java/net/
url_class_loader.rs1use alloc::{format, vec, vec::Vec};
2
3use jvm::{
4 Array, ClassInstanceRef, Jvm, Result,
5 runtime::{JavaIoInputStream, JavaLangString},
6};
7use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
8use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
9
10use crate::{
11 FileType, RuntimeClassProto, RuntimeContext,
12 classes::java::{
13 lang::{Class, ClassLoader, String},
14 net::{JarURLConnection, URL},
15 util::jar::JarEntry,
16 },
17};
18
19pub struct URLClassLoader;
21
22impl URLClassLoader {
23 pub fn as_proto() -> RuntimeClassProto {
24 RuntimeClassProto {
25 name: "java/net/URLClassLoader",
26 parent_class: Some("java/lang/ClassLoader"), interfaces: vec![],
28 methods: vec![
29 JavaMethodProto::new(
30 "<init>",
31 "([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
32 Self::init,
33 MethodAccessFlags::PUBLIC,
34 ),
35 JavaMethodProto::new(
36 "findClass",
37 "(Ljava/lang/String;)Ljava/lang/Class;",
38 Self::find_class,
39 MethodAccessFlags::PROTECTED,
40 ),
41 JavaMethodProto::new(
42 "findResource",
43 "(Ljava/lang/String;)Ljava/net/URL;",
44 Self::find_resource,
45 MethodAccessFlags::PUBLIC,
46 ),
47 ],
48 fields: vec![JavaFieldProto::new("urls", "[Ljava/net/URL;", FieldAccessFlags::PRIVATE)],
49 access_flags: ClassAccessFlags::PUBLIC,
50 }
51 }
52
53 async fn init(
54 jvm: &Jvm,
55 _: &mut RuntimeContext,
56 mut this: ClassInstanceRef<Self>,
57 urls: ClassInstanceRef<Array<URL>>,
58 parent: ClassInstanceRef<ClassLoader>,
59 ) -> Result<()> {
60 tracing::debug!("java.net.URLClassLoader::<init>({this:?}, {urls:?}, {parent:?})");
61
62 let _: () = jvm
63 .invoke_special(&this, "java/lang/ClassLoader", "<init>", "(Ljava/lang/ClassLoader;)V", (parent,))
64 .await?;
65
66 jvm.put_field(&mut this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;", urls)
67 .await?;
68
69 Ok(())
70 }
71
72 async fn find_class(
73 jvm: &Jvm,
74 _: &mut RuntimeContext,
75 this: ClassInstanceRef<Self>,
76 name: ClassInstanceRef<String>,
77 ) -> Result<ClassInstanceRef<Class>> {
78 tracing::debug!("java.net.URLClassLoader::findClass({this:?}, {name:?})");
79
80 let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
81
82 let resource_name = format!("{}.class", name_str.replace('.', "/"));
83 let resource_name = JavaLangString::from_rust_string(jvm, &resource_name).await?;
84
85 let resource: ClassInstanceRef<URL> = jvm
86 .invoke_virtual(
87 &this,
88 "java/net/URLClassLoader",
89 "findResource",
90 "(Ljava/lang/String;)Ljava/net/URL;",
91 (resource_name,),
92 )
93 .await?;
94 if resource.is_null() {
95 return Ok(None.into());
96 }
97
98 let stream = jvm
99 .invoke_virtual(&resource, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
100 .await?;
101 let bytes = JavaIoInputStream::read_until_end(jvm, &stream).await?;
102
103 let length = bytes.len() as i32;
104 let mut bytes_java = jvm.instantiate_array("B", bytes.len()).await?;
105 jvm.array_raw_buffer_mut(&mut bytes_java).await?.write(0, &bytes)?;
106
107 let class = jvm
108 .invoke_virtual(
109 &this,
110 "java/net/URLClassLoader",
111 "defineClass",
112 "(Ljava/lang/String;[BII)Ljava/lang/Class;",
113 (name, bytes_java.clone(), 0, length),
114 )
115 .await?;
116
117 Ok(class)
118 }
119
120 async fn find_resource(
121 jvm: &Jvm,
122 runtime: &mut RuntimeContext,
123 this: ClassInstanceRef<Self>,
124 name: ClassInstanceRef<String>,
125 ) -> Result<ClassInstanceRef<URL>> {
126 tracing::debug!("java.net.URLClassLoader::findResource({this:?}, {name:?})");
127
128 let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
129
130 let urls = jvm.get_field(&this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;").await?;
131 let urls: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;
132
133 for url in urls {
134 let file = jvm.invoke_virtual(&url, "java/net/URL", "getFile", "()Ljava/lang/String;", ()).await?;
135 let file = JavaLangString::to_rust_string(jvm, &file).await?;
136
137 let metadata = runtime.metadata(&file).await;
138 if file.ends_with('/') || file.is_empty() || metadata.as_ref().is_ok_and(|metadata| metadata.r#type == FileType::Directory) {
139 let final_path = if file.is_empty() {
141 name_str.clone()
142 } else if file.ends_with('/') {
143 format!("{file}{name_str}")
144 } else {
145 format!("{file}/{name_str}")
146 };
147
148 if runtime.metadata(&final_path).await.is_ok() {
149 let new_url = jvm
150 .new_class(
151 "java/net/URL",
152 "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
153 (
154 JavaLangString::from_rust_string(jvm, "file").await?,
155 JavaLangString::from_rust_string(jvm, "").await?,
156 JavaLangString::from_rust_string(jvm, &final_path).await?,
157 ),
158 )
159 .await?;
160
161 return Ok(new_url.into());
162 }
163 } else if metadata.is_err() {
164 continue;
165 } else {
166 let name_str = name_str.trim_start_matches('/');
168
169 let jar_url_str = format!("jar:file:{file}!/{name_str}"); let jar_url = JavaLangString::from_rust_string(jvm, &jar_url_str).await?;
171 let jar_url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (jar_url,)).await?;
172 let connection: ClassInstanceRef<JarURLConnection> = jvm
173 .invoke_virtual(&jar_url, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
174 .await?;
175
176 let entry: ClassInstanceRef<JarEntry> = jvm
177 .invoke_virtual(&connection, "java/net/JarURLConnection", "getJarEntry", "()Ljava/util/jar/JarEntry;", ())
178 .await?;
179
180 if !entry.is_null() {
181 return Ok(jar_url.into());
182 }
183 }
184 }
185
186 Ok(None.into())
187 }
188}