Skip to main content

rustjava_runtime/classes/java/net/
url_class_loader.rs

1use 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
19// class java.net.URLClassLoader
20pub 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"), // TODO java.security.SecureClassLoader
27            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        if urls.is_null() {
63            return Err(jvm.exception("java/lang/NullPointerException", "urls is null").await);
64        }
65        let entries: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;
66        if entries.iter().any(|url| url.is_null()) {
67            return Err(jvm.exception("java/lang/NullPointerException", "URL element is null").await);
68        }
69
70        let _: () = jvm
71            .invoke_special(&this, "java/lang/ClassLoader", "<init>", "(Ljava/lang/ClassLoader;)V", (parent,))
72            .await?;
73
74        jvm.put_field(&mut this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;", urls)
75            .await?;
76
77        Ok(())
78    }
79
80    async fn find_class(
81        jvm: &Jvm,
82        _: &mut RuntimeContext,
83        this: ClassInstanceRef<Self>,
84        name: ClassInstanceRef<String>,
85    ) -> Result<ClassInstanceRef<Class>> {
86        tracing::debug!("java.net.URLClassLoader::findClass({this:?}, {name:?})");
87
88        if name.is_null() {
89            return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
90        }
91
92        let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
93
94        let resource_name = format!("{}.class", name_str.replace('.', "/"));
95        let resource_name = JavaLangString::from_rust_string(jvm, &resource_name).await?;
96
97        let resource: ClassInstanceRef<URL> = jvm
98            .invoke_virtual(
99                &this,
100                "java/net/URLClassLoader",
101                "findResource",
102                "(Ljava/lang/String;)Ljava/net/URL;",
103                (resource_name,),
104            )
105            .await?;
106        if resource.is_null() {
107            return Ok(None.into());
108        }
109
110        let stream = jvm
111            .invoke_virtual(&resource, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
112            .await?;
113        let bytes = JavaIoInputStream::read_until_end(jvm, &stream).await?;
114
115        let length = bytes.len() as i32;
116        let mut bytes_java = jvm.instantiate_array("B", bytes.len()).await?;
117        jvm.array_raw_buffer_mut(&mut bytes_java).await?.write(0, &bytes)?;
118
119        let class = jvm
120            .invoke_virtual(
121                &this,
122                "java/net/URLClassLoader",
123                "defineClass",
124                "(Ljava/lang/String;[BII)Ljava/lang/Class;",
125                (name, bytes_java.clone(), 0, length),
126            )
127            .await?;
128
129        Ok(class)
130    }
131
132    async fn find_resource(
133        jvm: &Jvm,
134        runtime: &mut RuntimeContext,
135        this: ClassInstanceRef<Self>,
136        name: ClassInstanceRef<String>,
137    ) -> Result<ClassInstanceRef<URL>> {
138        tracing::debug!("java.net.URLClassLoader::findResource({this:?}, {name:?})");
139
140        if name.is_null() {
141            return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
142        }
143
144        let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
145
146        let urls = jvm.get_field(&this, "java/net/URLClassLoader", "urls", "[Ljava/net/URL;").await?;
147        let urls: Vec<ClassInstanceRef<URL>> = jvm.load_array(&urls, 0, jvm.array_length(&urls).await? as _).await?;
148
149        for url in urls {
150            let file: ClassInstanceRef<String> = jvm.invoke_virtual(&url, "java/net/URL", "getFile", "()Ljava/lang/String;", ()).await?;
151            let path = jvm
152                .invoke_static(
153                    "org/rustjava/net/URLPath",
154                    "decode",
155                    "(Ljava/lang/String;)Ljava/lang/String;",
156                    (file.clone(),),
157                )
158                .await?;
159            let file = JavaLangString::to_rust_string(jvm, &file).await?;
160            let path = JavaLangString::to_rust_string(jvm, &path).await?;
161
162            let metadata = runtime.metadata(&path).await;
163            if path.ends_with('/') || path.is_empty() || metadata.as_ref().is_ok_and(|metadata| metadata.r#type == FileType::Directory) {
164                // directory
165                let final_path = if path.is_empty() {
166                    name_str.clone()
167                } else if path.ends_with('/') {
168                    format!("{path}{name_str}")
169                } else {
170                    format!("{path}/{name_str}")
171                };
172
173                if runtime.metadata(&final_path).await.is_ok() {
174                    let final_path = JavaLangString::from_rust_string(jvm, &final_path).await?;
175                    let final_path: ClassInstanceRef<String> = jvm
176                        .invoke_static(
177                            "org/rustjava/net/URLPath",
178                            "encode",
179                            "(Ljava/lang/String;)Ljava/lang/String;",
180                            (final_path,),
181                        )
182                        .await?;
183                    let new_url = jvm
184                        .new_class(
185                            "java/net/URL",
186                            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
187                            (
188                                JavaLangString::from_rust_string(jvm, "file").await?,
189                                JavaLangString::from_rust_string(jvm, "").await?,
190                                final_path,
191                            ),
192                        )
193                        .await?;
194
195                    return Ok(new_url.into());
196                }
197            } else if metadata.is_err() {
198                continue;
199            } else {
200                // treat as jar
201                let name_str = name_str.trim_start_matches('/');
202                let entry = JavaLangString::from_rust_string(jvm, name_str).await?;
203                let entry = jvm
204                    .invoke_static("org/rustjava/net/URLPath", "encode", "(Ljava/lang/String;)Ljava/lang/String;", (entry,))
205                    .await?;
206                let entry = JavaLangString::to_rust_string(jvm, &entry).await?;
207                let jar_url_str = format!("jar:file:{file}!/{entry}"); // TODO url might not be file
208                let jar_url = JavaLangString::from_rust_string(jvm, &jar_url_str).await?;
209                let jar_url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (jar_url,)).await?;
210                let connection: ClassInstanceRef<JarURLConnection> = jvm
211                    .invoke_virtual(&jar_url, "java/net/URL", "openConnection", "()Ljava/net/URLConnection;", ())
212                    .await?;
213
214                let entry: ClassInstanceRef<JarEntry> = jvm
215                    .invoke_virtual(&connection, "java/net/JarURLConnection", "getJarEntry", "()Ljava/util/jar/JarEntry;", ())
216                    .await?;
217
218                if !entry.is_null() {
219                    return Ok(jar_url.into());
220                }
221            }
222        }
223
224        Ok(None.into())
225    }
226}