Skip to main content

rustjava_runtime/classes/java/lang/
class_loader.rs

1use alloc::{format, vec, vec::Vec};
2
3use jvm::{Array, 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        lang::{Class, String},
11        net::URL,
12    },
13};
14
15// class java.lang.ClassLoader
16pub struct ClassLoader;
17
18impl ClassLoader {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/lang/ClassLoader",
22            parent_class: Some("java/lang/Object"),
23            interfaces: vec![],
24            methods: vec![
25                JavaMethodProto::new("<init>", "(Ljava/lang/ClassLoader;)V", Self::init, MethodAccessFlags::PROTECTED),
26                JavaMethodProto::new(
27                    "loadClass",
28                    "(Ljava/lang/String;)Ljava/lang/Class;",
29                    Self::load_class,
30                    MethodAccessFlags::PUBLIC,
31                ),
32                JavaMethodProto::new(
33                    "findClass",
34                    "(Ljava/lang/String;)Ljava/lang/Class;",
35                    Self::find_class,
36                    MethodAccessFlags::PROTECTED,
37                ),
38                JavaMethodProto::new(
39                    "findLoadedClass",
40                    "(Ljava/lang/String;)Ljava/lang/Class;",
41                    Self::find_loaded_class,
42                    MethodAccessFlags::PROTECTED | MethodAccessFlags::FINAL,
43                ),
44                JavaMethodProto::new(
45                    "getSystemClassLoader",
46                    "()Ljava/lang/ClassLoader;",
47                    Self::get_system_class_loader,
48                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
49                ),
50                JavaMethodProto::new(
51                    "getResource",
52                    "(Ljava/lang/String;)Ljava/net/URL;",
53                    Self::get_resource,
54                    MethodAccessFlags::PUBLIC,
55                ),
56                JavaMethodProto::new(
57                    "getResourceAsStream",
58                    "(Ljava/lang/String;)Ljava/io/InputStream;",
59                    Self::get_resource_as_stream,
60                    MethodAccessFlags::PUBLIC,
61                ),
62                JavaMethodProto::new(
63                    "findResource",
64                    "(Ljava/lang/String;)Ljava/net/URL;",
65                    Self::find_resource,
66                    MethodAccessFlags::PROTECTED,
67                ),
68                JavaMethodProto::new(
69                    "defineClass",
70                    "(Ljava/lang/String;[BII)Ljava/lang/Class;",
71                    Self::define_class,
72                    MethodAccessFlags::PROTECTED | MethodAccessFlags::FINAL,
73                ),
74            ],
75            fields: vec![
76                JavaFieldProto::new("systemClassLoader", "Ljava/lang/ClassLoader;", FieldAccessFlags::STATIC),
77                JavaFieldProto::new("parent", "Ljava/lang/ClassLoader;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
78            ],
79            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
80        }
81    }
82
83    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, parent: ClassInstanceRef<Self>) -> Result<()> {
84        tracing::debug!("java.lang.ClassLoader::<init>({this:?}, {parent:?})");
85
86        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
87
88        jvm.put_field(&mut this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;", parent)
89            .await?;
90
91        Ok(())
92    }
93
94    async fn get_system_class_loader(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
95        tracing::debug!("java.lang.ClassLoader::getSystemClassLoader()");
96
97        let system_class_loader: ClassInstanceRef<Self> = jvm
98            .get_static_field("java/lang/ClassLoader", "systemClassLoader", "Ljava/lang/ClassLoader;")
99            .await?;
100
101        if system_class_loader.is_null() {
102            let class_path: ClassInstanceRef<String> = jvm
103                .invoke_static(
104                    "java/lang/System",
105                    "getProperty",
106                    "(Ljava/lang/String;)Ljava/lang/String;",
107                    (JavaLangString::from_rust_string(jvm, "java.class.path").await?,),
108                )
109                .await?;
110
111            let (class_paths, urls) = if !class_path.is_null() {
112                let class_path = JavaLangString::to_rust_string(jvm, &class_path).await?;
113                let path_separator: ClassInstanceRef<String> = jvm.get_static_field("java/io/File", "pathSeparator", "Ljava/lang/String;").await?;
114                let path_separator = JavaLangString::to_rust_string(jvm, &path_separator).await?;
115
116                let mut class_paths = Vec::new();
117                let mut urls = Vec::new();
118                for path in class_path.split(path_separator.as_str()) {
119                    let path = JavaLangString::from_rust_string(jvm, path).await?;
120                    class_paths.push(path.clone());
121                    let path = jvm
122                        .invoke_static("org/rustjava/net/URLPath", "encode", "(Ljava/lang/String;)Ljava/lang/String;", (path,))
123                        .await?;
124                    let path = JavaLangString::to_rust_string(jvm, &path).await?;
125                    let path = JavaLangString::from_rust_string(jvm, &format!("file:{path}")).await?;
126                    let url = jvm.new_class("java/net/URL", "(Ljava/lang/String;)V", (path,)).await?;
127                    urls.push(url);
128                }
129
130                (class_paths, urls)
131            } else {
132                (Vec::new(), Vec::new())
133            };
134
135            let mut class_path_array = jvm.instantiate_array("Ljava/lang/String;", class_paths.len()).await?;
136            jvm.store_array(&mut class_path_array, 0, class_paths).await?;
137            let rustjar_class_loader = jvm
138                .new_class(
139                    "org/rustjava/lang/RustJarClassLoader",
140                    "([Ljava/lang/String;Ljava/lang/ClassLoader;)V",
141                    (class_path_array, None),
142                )
143                .await?;
144
145            let mut url_array = jvm.instantiate_array("Ljava/net/URL;", urls.len()).await?;
146            jvm.store_array(&mut url_array, 0, urls).await?;
147
148            let url_class_loader = jvm
149                .new_class(
150                    "java/net/URLClassLoader",
151                    "([Ljava/net/URL;Ljava/lang/ClassLoader;)V",
152                    (url_array, rustjar_class_loader),
153                )
154                .await?;
155
156            let class_loader_type: ClassInstanceRef<String> = jvm
157                .invoke_static(
158                    "java/lang/System",
159                    "getProperty",
160                    "(Ljava/lang/String;)Ljava/lang/String;",
161                    (JavaLangString::from_rust_string(jvm, "java.system.class.loader").await?,),
162                )
163                .await?;
164
165            let system_class_loader = if !class_loader_type.is_null() {
166                let class_loader_type_str = JavaLangString::to_rust_string(jvm, &class_loader_type).await?;
167                jvm.new_class(&class_loader_type_str, "(Ljava/lang/ClassLoader;)V", (url_class_loader,))
168                    .await?
169            } else {
170                url_class_loader
171            };
172
173            jvm.put_static_field(
174                "java/lang/ClassLoader",
175                "systemClassLoader",
176                "Ljava/lang/ClassLoader;",
177                system_class_loader.clone(),
178            )
179            .await?;
180
181            return Ok(system_class_loader.into());
182        }
183
184        Ok(system_class_loader)
185    }
186
187    async fn load_class(
188        jvm: &Jvm,
189        runtime: &mut RuntimeContext,
190        this: ClassInstanceRef<Self>,
191        name: ClassInstanceRef<String>,
192    ) -> Result<ClassInstanceRef<Class>> {
193        tracing::debug!("java.lang.ClassLoader::loadClass({this:?}, {name:?})");
194
195        if name.is_null() {
196            return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
197        }
198
199        let class: ClassInstanceRef<Class> = jvm
200            .invoke_virtual(
201                &this,
202                "java/lang/ClassLoader",
203                "findLoadedClass",
204                "(Ljava/lang/String;)Ljava/lang/Class;",
205                (name.clone(),),
206            )
207            .await?;
208
209        if !class.is_null() {
210            return Ok(class);
211        }
212
213        let name_str = JavaLangString::to_rust_string(jvm, &name).await?;
214        let internal_name = name_str.replace('.', "/");
215
216        if let Some(element_type_name) = internal_name.strip_prefix('[') {
217            let ultimate_element_type = name_str.trim_start_matches('[');
218            let defining_loader = if let Some(element_class_name) = ultimate_element_type.strip_prefix('L').and_then(|name| name.strip_suffix(';')) {
219                let element_class_name = JavaLangString::from_rust_string(jvm, element_class_name).await?;
220                let element_class: ClassInstanceRef<Class> = jvm
221                    .invoke_virtual(
222                        &this,
223                        "java/lang/ClassLoader",
224                        "loadClass",
225                        "(Ljava/lang/String;)Ljava/lang/Class;",
226                        (element_class_name,),
227                    )
228                    .await?;
229                jvm.get_field(&element_class, "java/lang/Class", "classLoader", "Ljava/lang/ClassLoader;")
230                    .await?
231            } else {
232                None
233            };
234
235            let class = runtime.define_array_class(jvm, element_type_name).await?;
236            let java_class = jvm.register_class(class, defining_loader).await?;
237
238            return Ok(java_class.into());
239        }
240
241        let parent: ClassInstanceRef<Self> = jvm.get_field(&this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;").await?;
242        let class: ClassInstanceRef<Class> = if !parent.is_null() {
243            jvm.invoke_virtual(
244                &parent,
245                "java/lang/ClassLoader",
246                "loadClass",
247                "(Ljava/lang/String;)Ljava/lang/Class;",
248                (name.clone(),),
249            )
250            .await?
251        } else {
252            jvm.load_bootstrap_class(&internal_name).await?.into()
253        };
254
255        if !class.is_null() {
256            return Ok(class);
257        }
258
259        let class = jvm
260            .invoke_virtual(
261                &this,
262                "java/lang/ClassLoader",
263                "findClass",
264                "(Ljava/lang/String;)Ljava/lang/Class;",
265                (name,),
266            )
267            .await?;
268
269        Ok(class)
270    }
271
272    async fn find_class(
273        jvm: &Jvm,
274        _: &mut RuntimeContext,
275        this: ClassInstanceRef<Self>,
276        name: ClassInstanceRef<String>,
277    ) -> Result<ClassInstanceRef<Class>> {
278        tracing::debug!("java.lang.ClassLoader::findClass({this:?}, {name:?})");
279
280        Err(jvm.exception("java/lang/ClassNotFoundException", "class not found").await)
281    }
282
283    async fn find_loaded_class(
284        jvm: &Jvm,
285        _: &mut RuntimeContext,
286        this: ClassInstanceRef<Self>,
287        name: ClassInstanceRef<String>,
288    ) -> Result<ClassInstanceRef<Class>> {
289        tracing::debug!("java.lang.ClassLoader::findLoadedClass({this:?}, {name:?})");
290
291        if name.is_null() {
292            return Ok(None.into());
293        }
294
295        let internal_name = JavaLangString::to_rust_string(jvm, &name).await?.replace('.', "/");
296        if !jvm.has_class(&internal_name) {
297            return Ok(None.into());
298        }
299
300        let class = jvm.resolve_class(&internal_name).await?;
301
302        Ok(class.java_class().into())
303    }
304
305    async fn get_resource(
306        jvm: &Jvm,
307        _: &mut RuntimeContext,
308        this: ClassInstanceRef<Self>,
309        name: ClassInstanceRef<String>,
310    ) -> Result<ClassInstanceRef<URL>> {
311        tracing::debug!("java.lang.ClassLoader::getResource({this:?})");
312
313        if name.is_null() {
314            return Err(jvm.exception("java/lang/NullPointerException", "name is null").await);
315        }
316
317        let parent: ClassInstanceRef<Self> = jvm.get_field(&this, "java/lang/ClassLoader", "parent", "Ljava/lang/ClassLoader;").await?;
318
319        let result: ClassInstanceRef<URL> = if !parent.is_null() {
320            jvm.invoke_virtual(
321                &parent,
322                "java/lang/ClassLoader",
323                "getResource",
324                "(Ljava/lang/String;)Ljava/net/URL;",
325                (name.clone(),),
326            )
327            .await?
328        } else {
329            None.into()
330        };
331
332        if !result.is_null() {
333            return Ok(result);
334        }
335
336        let result = jvm
337            .invoke_virtual(
338                &this,
339                "java/lang/ClassLoader",
340                "findResource",
341                "(Ljava/lang/String;)Ljava/net/URL;",
342                (name,),
343            )
344            .await?;
345
346        Ok(result)
347    }
348
349    async fn get_resource_as_stream(
350        jvm: &Jvm,
351        _: &mut RuntimeContext,
352        this: ClassInstanceRef<Self>,
353        name: ClassInstanceRef<String>,
354    ) -> Result<ClassInstanceRef<URL>> {
355        tracing::debug!("java.lang.ClassLoader::getResourceAsStream({this:?})");
356
357        let resource_url: ClassInstanceRef<URL> = jvm
358            .invoke_virtual(
359                &this,
360                "java/lang/ClassLoader",
361                "getResource",
362                "(Ljava/lang/String;)Ljava/net/URL;",
363                (name.clone(),),
364            )
365            .await?;
366
367        if resource_url.is_null() {
368            return Ok(None.into());
369        }
370
371        let stream = jvm
372            .invoke_virtual(&resource_url, "java/net/URL", "openStream", "()Ljava/io/InputStream;", ())
373            .await?;
374
375        Ok(stream)
376    }
377
378    async fn find_resource(
379        _: &Jvm,
380        _: &mut RuntimeContext,
381        this: ClassInstanceRef<Self>,
382        _: ClassInstanceRef<String>,
383    ) -> Result<ClassInstanceRef<URL>> {
384        tracing::debug!("java.lang.ClassLoader::findResource({this:?})");
385
386        Ok(None.into())
387    }
388
389    async fn define_class(
390        jvm: &Jvm,
391        runtime: &mut RuntimeContext,
392        this: ClassInstanceRef<Self>,
393        name: ClassInstanceRef<String>,
394        bytes: ClassInstanceRef<Array<i8>>,
395        offset: i32,
396        length: i32,
397    ) -> Result<ClassInstanceRef<Class>> {
398        tracing::debug!("java.lang.ClassLoader::defineClass({this:?}, {name:?}, {bytes:?}, {offset:?}, {length:?})");
399
400        if bytes.is_null() {
401            return Err(jvm.exception("java/lang/NullPointerException", "class bytes").await);
402        }
403        let array_length = jvm.array_length(&bytes).await?;
404        if offset < 0 || length < 0 || (offset as usize).checked_add(length as usize).is_none_or(|end| end > array_length) {
405            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid class byte range").await);
406        }
407
408        let mut data = vec![0; length as usize];
409        jvm.array_raw_buffer(&bytes).await?.read(offset as _, &mut data)?;
410
411        let class = runtime.define_class(jvm, &data).await?;
412        let java_class = jvm.register_class(class, Some(this.into())).await?;
413
414        Ok(java_class.into())
415    }
416}