Initial import
[jpf-core.git] / src / peers / gov / nasa / jpf / vm / JPF_java_lang_ClassLoader.java
1 /*
2  * Copyright (C) 2014, United States Government, as represented by the
3  * Administrator of the National Aeronautics and Space Administration.
4  * All rights reserved.
5  *
6  * The Java Pathfinder core (jpf-core) platform is licensed under the
7  * Apache License, Version 2.0 (the "License"); you may not use this file except
8  * in compliance with the License. You may obtain a copy of the License at
9  * 
10  *        http://www.apache.org/licenses/LICENSE-2.0. 
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and 
16  * limitations under the License.
17  */
18 package gov.nasa.jpf.vm;
19
20 import java.util.Map;
21
22 import gov.nasa.jpf.annotation.MJI;
23 import gov.nasa.jpf.vm.ClassPath;
24 import gov.nasa.jpf.vm.ClassInfo;
25 import gov.nasa.jpf.vm.ClassLoaderInfo;
26 import gov.nasa.jpf.vm.ClassInfoException;
27 import gov.nasa.jpf.vm.ClinitRequired;
28 import gov.nasa.jpf.vm.ElementInfo;
29 import gov.nasa.jpf.vm.Heap;
30 import gov.nasa.jpf.vm.MJIEnv;
31 import gov.nasa.jpf.vm.NativePeer;
32 import gov.nasa.jpf.vm.ThreadInfo;
33
34 /**
35  * @author Nastaran Shafiei <nastaran.shafiei@gmail.com>
36  * 
37  * Native peer for java.lang.ClassLoader
38  */
39 public class JPF_java_lang_ClassLoader extends NativePeer {
40
41   @MJI
42   public void $init____V (MJIEnv env, int objRef) {
43     ClassLoaderInfo systemCl = ClassLoaderInfo.getCurrentSystemClassLoader();
44     $init__Ljava_lang_ClassLoader_2__V (env, objRef, systemCl.getClassLoaderObjectRef());
45   }
46
47   @MJI
48   public void $init__Ljava_lang_ClassLoader_2__V (MJIEnv env, int objRef, int parentRef) {
49     Heap heap = env.getHeap();
50
51     //--- Retrieve the parent ClassLoaderInfo
52     ClassLoaderInfo parent = env.getClassLoaderInfo(parentRef);
53
54     //--- create the internal representation of the classloader
55     ClassLoaderInfo cl = new ClassLoaderInfo(env.getVM(), objRef, new ClassPath(), parent);
56
57     //--- initialize the java.lang.ClassLoader object
58     ElementInfo ei = heap.getModifiable(objRef);
59     ei.setIntField( ClassLoaderInfo.ID_FIELD, cl.getId());
60
61     // we should use the following block if we ever decide to make systemClassLoader 
62     // unavailable if(parent.isSystemClassLoader) {
63     //  // we don't want to make the systemCLassLoader available through SUT
64     //  parentRef = MJIEnv.NULL;
65     // }
66
67     ei.setReferenceField("parent", parentRef);
68   }
69
70   @MJI
71   public int getSystemClassLoader____Ljava_lang_ClassLoader_2 (MJIEnv env, int clsObjRef) {
72     return ClassLoaderInfo.getCurrentSystemClassLoader().getClassLoaderObjectRef();
73   }
74
75   @MJI
76   public int getResource0__Ljava_lang_String_2__Ljava_lang_String_2 (MJIEnv env, int objRef, int resRef){
77     String rname = env.getStringObject(resRef);
78
79     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
80
81     String resourcePath = cl.findResource(rname);
82
83     return env.newString(resourcePath);
84   }
85
86   @MJI
87   public int getResources0__Ljava_lang_String_2___3Ljava_lang_String_2 (MJIEnv env, int objRef, int resRef) {
88     String rname = env.getStringObject(resRef);
89
90     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
91
92     String[] resources = cl.findResources(rname);
93
94     return env.newStringArray(resources);
95   }
96
97   @MJI
98   public int findLoadedClass__Ljava_lang_String_2__Ljava_lang_Class_2 (MJIEnv env, int objRef, int nameRef) {
99     String cname = env.getStringObject(nameRef);
100
101     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
102
103     ClassInfo ci = cl.getAlreadyResolvedClassInfo(cname);
104     if(ci != null) {
105       return ci.getClassObjectRef();
106     }
107
108     return MJIEnv.NULL;
109   }
110
111   @MJI
112   public int findSystemClass__Ljava_lang_String_2__Ljava_lang_Class_2 (MJIEnv env, int objRef, int nameRef) {
113     String cname = env.getStringObject(nameRef);
114
115     checkForIllegalName(env, cname);
116     if(env.hasException()) {
117       return MJIEnv.NULL;
118     }
119
120     ClassLoaderInfo cl = ClassLoaderInfo.getCurrentSystemClassLoader();
121
122     ClassInfo ci = cl.getResolvedClassInfo(cname);
123
124     if(!ci.isRegistered()) {
125       ci.registerClass(env.getThreadInfo());
126     }
127
128     return ci.getClassObjectRef();
129   }
130
131   @MJI
132   public int defineClass0__Ljava_lang_String_2_3BII__Ljava_lang_Class_2 
133                                       (MJIEnv env, int objRef, int nameRef, int bufferRef, int offset, int length) {
134     String cname = env.getStringObject(nameRef);
135     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
136
137     // determine whether that the corresponding class is already defined by this 
138     // classloader, if so, this attempt is invalid, and loading throws a LinkageError
139     if (cl.getDefinedClassInfo(cname) != null) {  // attempt to define twice
140       env.throwException("java.lang.LinkageError"); 
141       return MJIEnv.NULL;
142     }
143         
144     byte[] buffer = env.getByteArrayObject(bufferRef);
145     
146     try {
147       ClassInfo ci = cl.getResolvedClassInfo( cname, buffer, offset, length);
148
149       // Note: if the representation is not of a supported major or minor version, loading 
150       // throws an UnsupportedClassVersionError. But for now, we do not check for this here 
151       // since we don't do much with minor and major versions
152
153       ThreadInfo ti = env.getThreadInfo();
154       ci.registerClass(ti);
155
156       return ci.getClassObjectRef();
157       
158     } catch (ClassInfoException cix){
159       env.throwException("java.lang.ClassFormatError");
160       return MJIEnv.NULL;
161     }
162   }
163
164
165   protected static boolean check(MJIEnv env, String cname, byte[] buffer, int offset, int length) {
166     // throw SecurityExcpetion if the package prefix is java
167     checkForProhibitedPkg(env, cname);
168
169     // throw NoClassDefFoundError if the given class does name might 
170     // not be a valid binary name
171     checkForIllegalName(env, cname);
172
173     // throw IndexOutOfBoundsException if buffer length is not consistent
174     // with offset
175     checkData(env, buffer, offset, length);
176
177     return !env.hasException();
178   }
179
180   protected static void checkForProhibitedPkg(MJIEnv env, String name) {
181     if(name != null && name.startsWith("java.")) {
182       env.throwException("java.lang.SecurityException", "Prohibited package name: " + name);
183     }
184   }
185
186   protected static void checkForIllegalName(MJIEnv env, String name) {
187     if((name == null) || (name.length() == 0)) {
188       return;
189     }
190
191     if((name.indexOf('/') != -1) || (name.charAt(0) == '[')) {
192       env.throwException("java.lang.NoClassDefFoundError", "IllegalName: " + name);
193     }
194   }
195
196   protected static void checkData(MJIEnv env, byte[] buffer, int offset, int length) {
197     if(offset<0 || length<0 || offset+length > buffer.length) {
198       env.throwException("java.lang.IndexOutOfBoundsException");
199     }
200   }
201
202   static String pkg_class_name = "java.lang.Package";
203
204   @MJI
205   public int getPackages_____3Ljava_lang_Package_2 (MJIEnv env, int objRef) {
206     ClassLoaderInfo sysLoader = ClassLoaderInfo.getCurrentSystemClassLoader();
207     ClassInfo pkgClass = null; 
208     try {
209       pkgClass = sysLoader.getInitializedClassInfo(pkg_class_name, env.getThreadInfo());
210     } catch (ClinitRequired x){
211       env.handleClinitRequest(x.getRequiredClassInfo());
212       return MJIEnv.NULL;
213     }
214
215     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
216     // Returns all of the Packages defined by this class loader and its ancestors
217     Map<String, ClassLoaderInfo> pkgs = cl.getPackages();
218     int size = pkgs.size();
219     // create an array of type java.lang.Package
220     int pkgArr = env.newObjectArray(pkg_class_name, size);
221
222     int i = 0;
223     for(String name: cl.getPackages().keySet()) {
224       int pkgRef = createPackageObject(env, pkgClass, name, cl);
225       // place the object into the array
226       env.setReferenceArrayElement(pkgArr, i++, pkgRef);
227     }
228
229     return pkgArr;
230   }
231
232   @MJI
233   public int getPackage__Ljava_lang_String_2__Ljava_lang_Package_2 (MJIEnv env, int objRef, int nameRef) {
234     ClassLoaderInfo sysLoader = ClassLoaderInfo.getCurrentSystemClassLoader();
235
236     ClassInfo pkgClass = null; 
237     try {
238       pkgClass = sysLoader.getInitializedClassInfo(pkg_class_name, env.getThreadInfo());
239     } catch (ClinitRequired x){
240       env.handleClinitRequest(x.getRequiredClassInfo());
241       return MJIEnv.NULL;
242     }
243
244     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
245     String pkgName = env.getStringObject(nameRef);
246     if(cl.getPackages().get(pkgName)!=null) {
247       return createPackageObject(env, pkgClass, pkgName, cl);
248     } else {
249       return MJIEnv.NULL;
250     }
251   }
252
253   public static int createPackageObject(MJIEnv env, ClassInfo pkgClass, String pkgName, ClassLoaderInfo cl) {
254     int pkgRef = env.newObject(pkgClass);
255     ElementInfo ei = env.getModifiableElementInfo(pkgRef);
256
257     ei.setReferenceField("pkgName", env.newString(pkgName));
258     ei.setReferenceField("loader", cl.getClassLoaderObjectRef());
259     // the rest of the fields set to some dummy value
260     ei.setReferenceField("specTitle", env.newString("spectitle"));
261     ei.setReferenceField("specVersion", env.newString("specversion"));
262     ei.setReferenceField("specVendor", env.newString("specvendor"));
263     ei.setReferenceField("implTitle", env.newString("impltitle"));
264     ei.setReferenceField("implVersion", env.newString("implversion"));
265     ei.setReferenceField("sealBase", MJIEnv.NULL);
266
267     return pkgRef;
268   }
269
270   @MJI
271   public void setDefaultAssertionStatus__Z__V (MJIEnv env, int objRef, boolean enabled) {
272     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
273     cl.setDefaultAssertionStatus(enabled);
274   }
275
276   @MJI
277   public void setPackageAssertionStatus__Ljava_lang_String_2Z__V (MJIEnv env, int objRef, int strRef, boolean enabled) {
278     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
279     String pkgName = env.getStringObject(strRef);
280     cl.setPackageAssertionStatus(pkgName, enabled);
281   }
282
283   @MJI
284   public void setClassAssertionStatus__Ljava_lang_String_2Z__V (MJIEnv env, int objRef, int strRef, boolean enabled) {
285     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
286     String clsName = env.getStringObject(strRef);
287     cl.setClassAssertionStatus(clsName, enabled);
288   }
289
290   @MJI
291   public void clearAssertionStatus____V (MJIEnv env, int objRef) {
292     ClassLoaderInfo cl = env.getClassLoaderInfo(objRef);
293     cl.clearAssertionStatus();
294   }
295 }