This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
Patch: FYI: jumbo security patch
- From: Tom Tromey <tromey at redhat dot com>
- To: GCC libjava patches <java-patches at gcc dot gnu dot org>
- Date: 20 Jul 2003 19:41:34 -0600
- Subject: Patch: FYI: jumbo security patch
- Reply-to: tromey at redhat dot com
I'm checking this in on the trunk.
This adds a bunch of missing SecurityManager checks in Class and
java.lang.reflect.
Tested on x86 Red Hat Linux 9 against mauve and jacks (well, tried
against jacks -- we're having test suite problems there). No
regressions.
"No regressions" isn't saying a whole lot, since we don't have tests
for any of this stuff in the first place. I wrote a Mauve test for
the java.io.File SecurityManager calls. Hopefully there are more to
come...
There is still one place in Class where we are missing a security
call. That's because we don't correctly implement Class.getClasses.
(Nor can we -- we are missing the required reflection info for this,
for exception information on a Method, and we need to add another
field to implement Class.getSigners.)
Anyway, this is a step forward, though as Mark points out we must
still implement AccessController.
Tom
Index: ChangeLog
from Tom Tromey <tromey@redhat.com>
* java/lang/Runtime.java: Comment fix.
* java/lang/ClassLoader.java (isAncestorOf): New method.
(getParent): Uncommented security check. Use isAncestorOf.
* include/jvm.h (_Jv_CheckAccess): Declare.
* java/lang/reflect/natConstructor.cc (newInstance): Perform
access check.
Include IllegalAccessException.h, ArrayIndexOutOfBoundsException.h.
* java/lang/reflect/natArray.cc (newInstance): Pass caller's
class loader to _Jv_GetArrayClass.
Include ArrayIndexOutOfBoundsException.h.
* java/lang/reflect/Field.java: Update comment to reflect status.
(equals): Fixed indentation.
* java/lang/Class.h (Class): Declare memberAccessCheck, not
checkMemberAccess. Make _Jv_CheckAccess a friend.
* java/lang/Class.java (memberAccessCheck): New method from
Classpath.
(checkMemberAccess): Removed.
(getDeclaredMethod): Use memberAccessCheck.
(getField): Likewise.
(getMethod): Likewise.
* resolve.cc (_Jv_ResolvePoolEntry): Use _Jv_CheckAccess.
(_Jv_SearchMethodInClass): Likewise.
* prims.cc (_Jv_CheckAccess): New function.
* jni.cc (_Jv_JNI_FindClass): Use getClassLoaderInternal.
(_Jv_JNI_GetAnyFieldID): Likewise.
* java/lang/natClass.cc (forName): Use getClassLoaderInternal.
(getClassLoader): Added security check.
(getConstructor): Call memberAccessCheck.
(getDeclaredClasses): Likewise.
(getDeclaredField): Likewise.
(getDeclaredFields): Likewise.
(_getConstructors): Likewise.
(getDeclaredConstructor): Likewise.
(getDeclaredMethods): Likewise.
(getFields): Likewise.
(getMethods): Likewise.
(newInstance): Likewise.
(_Jv_MakeVTable): Put method name in exception.
* java/lang/reflect/natMethod.cc (getType): Use
getClassLoaderInternal.
(_Jv_GetTypesFromSignature): Likewise.
(invoke): Perform access check.
(_Jv_CallAnyMethodA): Removed old FIXME comments.
Include ArrayIndexOutOfBoundsException.h.
* java/lang/reflect/natField.cc (getType): Use
getClassLoaderInternal.
(_Jv_CheckFieldAccessibility): Removed.
(getAddr): Use _Jv_CheckAccess; find caller.
Include ArrayIndexOutOfBoundsException.h.
Index: jni.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/jni.cc,v
retrieving revision 1.72
diff -u -r1.72 jni.cc
--- jni.cc 17 Jun 2003 19:09:55 -0000 1.72
+++ jni.cc 21 Jul 2003 01:44:47 -0000
@@ -491,7 +491,7 @@
java::lang::ClassLoader *loader = NULL;
if (env->klass != NULL)
- loader = env->klass->getClassLoader ();
+ loader = env->klass->getClassLoaderInternal ();
if (loader == NULL)
{
@@ -1189,7 +1189,7 @@
// FIXME: what if field_class == NULL?
- java::lang::ClassLoader *loader = clazz->getClassLoader ();
+ java::lang::ClassLoader *loader = clazz->getClassLoaderInternal ();
while (clazz != NULL)
{
// We acquire the class lock so that fields aren't resolved
Index: prims.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/prims.cc,v
retrieving revision 1.80
diff -u -r1.80 prims.cc
--- prims.cc 13 Jun 2003 12:20:45 -0000 1.80
+++ prims.cc 21 Jul 2003 01:44:48 -0000
@@ -1,6 +1,6 @@
// prims.cc - Code for core of runtime environment.
-/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj.
@@ -1136,4 +1136,22 @@
return 0;
return dividend % divisor;
+}
+
+
+
+// Return true if SELF_KLASS can access a field or method in
+// OTHER_KLASS. The field or method's access flags are specified in
+// FLAGS.
+jboolean
+_Jv_CheckAccess (jclass self_klass, jclass other_klass, jint flags)
+{
+ using namespace java::lang::reflect;
+ return ((self_klass == other_klass)
+ || ((flags & Modifier::PUBLIC) != 0)
+ || (((flags & Modifier::PROTECTED) != 0)
+ && other_klass->isAssignableFrom (self_klass))
+ || (((flags & Modifier::PRIVATE) == 0)
+ && _Jv_ClassNameSamePackage (self_klass->name,
+ other_klass->name)));
}
Index: resolve.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/resolve.cc,v
retrieving revision 1.40
diff -u -r1.40 resolve.cc
--- resolve.cc 23 Apr 2003 19:09:56 -0000 1.40
+++ resolve.cc 21 Jul 2003 01:44:48 -0000
@@ -166,15 +166,7 @@
if (! _Jv_equalUtf8Consts (field->name, field_name))
continue;
- // now, check field access.
-
- if ( (cls == klass)
- || ((field->flags & Modifier::PUBLIC) != 0)
- || (((field->flags & Modifier::PROTECTED) != 0)
- && cls->isAssignableFrom (klass))
- || (((field->flags & Modifier::PRIVATE) == 0)
- && _Jv_ClassNameSamePackage (cls->name,
- klass->name)))
+ if (_Jv_CheckAccess (klass, cls, field->flags))
{
/* resove the field using the class' own loader
if necessary */
@@ -347,20 +339,10 @@
method_signature)))
continue;
- if (cls == klass
- || ((method->accflags & Modifier::PUBLIC) != 0)
- || (((method->accflags & Modifier::PROTECTED) != 0)
- && cls->isAssignableFrom (klass))
- || (((method->accflags & Modifier::PRIVATE) == 0)
- && _Jv_ClassNameSamePackage (cls->name,
- klass->name)))
- {
- return method;
- }
+ if (_Jv_CheckAccess (klass, cls, method->accflags))
+ return method;
else
- {
- throw new java::lang::IllegalAccessError;
- }
+ throw new java::lang::IllegalAccessError;
}
return 0;
}
Index: include/jvm.h
===================================================================
RCS file: /cvs/gcc/gcc/libjava/include/jvm.h,v
retrieving revision 1.55
diff -u -r1.55 jvm.h
--- include/jvm.h 25 Apr 2003 16:48:13 -0000 1.55
+++ include/jvm.h 21 Jul 2003 01:44:49 -0000
@@ -1,6 +1,6 @@
// jvm.h - Header file for private implementation information. -*- c++ -*-
-/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj.
@@ -325,6 +325,9 @@
jclass declaringClass,
JArray<jclass> **arg_types_out,
jclass *return_type_out);
+
+extern jboolean _Jv_CheckAccess (jclass self_klass, jclass other_klass,
+ jint flags);
extern jobject _Jv_CallAnyMethodA (jobject obj, jclass return_type,
jmethodID meth, jboolean is_constructor,
Index: java/lang/Class.h
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Class.h,v
retrieving revision 1.55
diff -u -r1.55 Class.h
--- java/lang/Class.h 20 Jan 2003 06:46:28 -0000 1.55
+++ java/lang/Class.h 21 Jul 2003 01:44:49 -0000
@@ -243,7 +243,7 @@
private:
- void checkMemberAccess (jint flags);
+ void memberAccessCheck (jint flags);
void initializeClass (void);
@@ -327,6 +327,9 @@
friend void _Jv_LayoutVTableMethods (jclass klass);
friend void _Jv_SetVTableEntries (jclass, _Jv_VTable *, jboolean *);
friend void _Jv_MakeVTable (jclass);
+
+ friend jboolean _Jv_CheckAccess (jclass self_klass, jclass other_klass,
+ jint flags);
// Return array class corresponding to element type KLASS, creating it if
// necessary.
Index: java/lang/Class.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Class.java,v
retrieving revision 1.15
diff -u -r1.15 Class.java
--- java/lang/Class.java 22 Feb 2003 14:16:29 -0000 1.15
+++ java/lang/Class.java 21 Jul 2003 01:44:49 -0000
@@ -72,14 +72,7 @@
public Method getDeclaredMethod (String methodName, Class[] parameterTypes)
throws NoSuchMethodException, SecurityException
{
- SecurityManager sm = System.getSecurityManager();
- if (sm != null)
- {
- sm.checkMemberAccess(this, Member.DECLARED);
- Package p = getPackage();
- if (p != null)
- sm.checkPackageAccess(p.getName());
- }
+ memberAccessCheck(Member.DECLARED);
if ("<init>".equals(methodName) || "<clinit>".equals(methodName))
throw new NoSuchMethodException(methodName);
@@ -101,9 +94,7 @@
public Field getField (String fieldName)
throws NoSuchFieldException, SecurityException
{
- SecurityManager s = System.getSecurityManager();
- if (s != null)
- s.checkMemberAccess (this, java.lang.reflect.Member.DECLARED);
+ memberAccessCheck (Member.PUBLIC);
Field fld = getField(fieldName, fieldName.hashCode());
if (fld == null)
throw new NoSuchFieldException(fieldName);
@@ -148,14 +139,7 @@
public Method getMethod (String methodName, Class[] parameterTypes)
throws NoSuchMethodException, SecurityException
{
- SecurityManager sm = System.getSecurityManager();
- if (sm != null)
- {
- sm.checkMemberAccess(this, Member.PUBLIC);
- Package p = getPackage();
- if (p != null)
- sm.checkPackageAccess(p.getName());
- }
+ memberAccessCheck(Member.PUBLIC);
if ("<init>".equals(methodName) || "<clinit>".equals(methodName))
throw new NoSuchMethodException(methodName);
@@ -334,14 +318,6 @@
{
}
- // Do a security check.
- private void checkMemberAccess (int flags)
- {
- SecurityManager sm = System.getSecurityManager();
- if (sm != null)
- sm.checkMemberAccess(this, flags);
- }
-
// Initialize the class.
private native void initializeClass ();
@@ -360,5 +336,21 @@
if (lastInd == -1)
return "";
return name.substring(0, lastInd);
+ }
+
+ /**
+ * Perform security checks common to all of the methods that
+ * get members of this Class.
+ */
+ private void memberAccessCheck(int which)
+ {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null)
+ {
+ sm.checkMemberAccess(this, which);
+ Package pkg = getPackage();
+ if (pkg != null)
+ sm.checkPackageAccess(pkg.getName());
+ }
}
}
Index: java/lang/ClassLoader.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/ClassLoader.java,v
retrieving revision 1.28
diff -u -r1.28 ClassLoader.java
--- java/lang/ClassLoader.java 12 Jun 2003 03:13:14 -0000 1.28
+++ java/lang/ClassLoader.java 21 Jul 2003 01:44:50 -0000
@@ -162,12 +162,10 @@
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
- /* FIXME: security, getClassContext() not implemented.
Class c = VMSecurityManager.getClassContext()[1];
ClassLoader cl = c.getClassLoader();
- if (cl != null && cl != this)
+ if (cl != null && ! cl.isAncestorOf(this))
sm.checkPermission(new RuntimePermission("getClassLoader"));
- */
}
return parent;
}
@@ -995,5 +993,21 @@
defaultAssertionStatus = false;
packageAssertionStatus = new HashMap();
classAssertionStatus = new HashMap();
+ }
+
+ /**
+ * Return true if this loader is either the specified class loader
+ * or an ancestor thereof.
+ * @param loader the class loader to check
+ */
+ final boolean isAncestorOf(ClassLoader loader)
+ {
+ while (loader != null)
+ {
+ if (this == loader)
+ return true;
+ loader = loader.parent;
+ }
+ return false;
}
}
Index: java/lang/Runtime.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/Runtime.java,v
retrieving revision 1.12
diff -u -r1.12 Runtime.java
--- java/lang/Runtime.java 14 Aug 2002 01:07:59 -0000 1.12
+++ java/lang/Runtime.java 21 Jul 2003 01:44:50 -0000
@@ -1,5 +1,5 @@
/* Runtime.java -- access to the VM process
- Copyright (C) 1998, 2002 Free Software Foundation
+ Copyright (C) 1998, 2002, 2003 Free Software Foundation
This file is part of GNU Classpath.
@@ -65,7 +65,7 @@
/**
* The current security manager. This is located here instead of in
- * Runtime, to avoid security problems, as well as bootstrap issues.
+ * System, to avoid security problems, as well as bootstrap issues.
* Make sure to access it in a thread-safe manner; it is package visible
* to avoid overhead in java.lang.
*/
Index: java/lang/natClass.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/natClass.cc,v
retrieving revision 1.62
diff -u -r1.62 natClass.cc
--- java/lang/natClass.cc 1 May 2003 21:36:18 -0000 1.62
+++ java/lang/natClass.cc 21 Jul 2003 01:44:50 -0000
@@ -101,7 +101,7 @@
{
klass = t->classAt (i);
}
- loader = klass->getClassLoader();
+ loader = klass->getClassLoaderInternal();
}
catch (::java::lang::ArrayIndexOutOfBoundsException *e)
{
@@ -113,13 +113,31 @@
java::lang::ClassLoader *
java::lang::Class::getClassLoader (void)
{
-#if 0
- // FIXME: the checks we need to do are more complex. See the spec.
- // Currently we can't implement them.
java::lang::SecurityManager *s = java::lang::System::getSecurityManager();
if (s != NULL)
- s->checkPermission (new RuntimePermission (JvNewStringLatin1 ("getClassLoader")));
-#endif
+ {
+ gnu::gcj::runtime::StackTrace *t
+ = new gnu::gcj::runtime::StackTrace(4);
+ Class *caller = NULL;
+ ClassLoader *caller_loader = NULL;
+ try
+ {
+ for (int i = 1; !caller; i++)
+ {
+ caller = t->classAt (i);
+ }
+ caller_loader = caller->getClassLoaderInternal();
+ }
+ catch (::java::lang::ArrayIndexOutOfBoundsException *e)
+ {
+ }
+
+ // If the caller has a non-null class loader, and that loader
+ // is not this class' loader or an ancestor thereof, then do a
+ // security check.
+ if (caller_loader != NULL && ! caller_loader->isAncestorOf(loader))
+ s->checkPermission (new RuntimePermission (JvNewStringLatin1 ("getClassLoader")));
+ }
// The spec requires us to return `null' for primitive classes. In
// other cases we have the option of returning `null' for classes
@@ -136,13 +154,14 @@
java::lang::reflect::Constructor *
java::lang::Class::getConstructor (JArray<jclass> *param_types)
{
+ memberAccessCheck(java::lang::reflect::Member::PUBLIC);
+
jstring partial_sig = getSignature (param_types, true);
jint hash = partial_sig->hashCode ();
int i = isPrimitive () ? 0 : method_count;
while (--i >= 0)
{
- // FIXME: access checks.
if (_Jv_equalUtf8Consts (methods[i].name, init_name)
&& _Jv_equal (methods[i].signature, partial_sig, hash))
{
@@ -163,7 +182,7 @@
JArray<java::lang::reflect::Constructor *> *
java::lang::Class::_getConstructors (jboolean declared)
{
- // FIXME: this method needs access checks.
+ memberAccessCheck(java::lang::reflect::Member::PUBLIC);
int numConstructors = 0;
int max = isPrimitive () ? 0 : method_count;
@@ -206,13 +225,14 @@
java::lang::reflect::Constructor *
java::lang::Class::getDeclaredConstructor (JArray<jclass> *param_types)
{
+ memberAccessCheck(java::lang::reflect::Member::DECLARED);
+
jstring partial_sig = getSignature (param_types, true);
jint hash = partial_sig->hashCode ();
int i = isPrimitive () ? 0 : method_count;
while (--i >= 0)
{
- // FIXME: access checks.
if (_Jv_equalUtf8Consts (methods[i].name, init_name)
&& _Jv_equal (methods[i].signature, partial_sig, hash))
{
@@ -256,9 +276,7 @@
java::lang::reflect::Field *
java::lang::Class::getDeclaredField (jstring name)
{
- java::lang::SecurityManager *s = java::lang::System::getSecurityManager();
- if (s != NULL)
- s->checkMemberAccess (this, java::lang::reflect::Member::DECLARED);
+ memberAccessCheck(java::lang::reflect::Member::DECLARED);
int hash = name->hashCode();
for (int i = 0; i < field_count; i++)
{
@@ -277,9 +295,7 @@
JArray<java::lang::reflect::Field *> *
java::lang::Class::getDeclaredFields (void)
{
- java::lang::SecurityManager *s = java::lang::System::getSecurityManager();
- if (s != NULL)
- s->checkMemberAccess (this, java::lang::reflect::Member::DECLARED);
+ memberAccessCheck(java::lang::reflect::Member::DECLARED);
JArray<java::lang::reflect::Field *> *result
= (JArray<java::lang::reflect::Field *> *)
JvNewObjectArray (field_count, &java::lang::reflect::Field::class$, NULL);
@@ -361,6 +377,8 @@
JArray<java::lang::reflect::Method *> *
java::lang::Class::getDeclaredMethods (void)
{
+ memberAccessCheck(java::lang::reflect::Member::DECLARED);
+
int numMethods = 0;
int max = isPrimitive () ? 0 : method_count;
int i;
@@ -424,7 +442,7 @@
JArray<jclass> *
java::lang::Class::getDeclaredClasses (void)
{
- checkMemberAccess (java::lang::reflect::Member::DECLARED);
+ memberAccessCheck (java::lang::reflect::Member::DECLARED);
// Until we have inner classes, it always makes sense to return an
// empty array.
JArray<jclass> *result
@@ -482,9 +500,7 @@
JArray<java::lang::reflect::Field *> *
java::lang::Class::getFields (void)
{
- // FIXME: security checking.
-
- using namespace java::lang::reflect;
+ memberAccessCheck(java::lang::reflect::Member::PUBLIC);
int count = _getFields (NULL, 0);
@@ -518,7 +534,6 @@
int i = klass->isPrimitive () ? 0 : klass->method_count;
while (--i >= 0)
{
- // FIXME: access checks.
if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name)
&& _Jv_equaln (klass->methods[i].signature, partial_sig, p_len)
&& (klass->methods[i].accflags
@@ -642,7 +657,7 @@
{
using namespace java::lang::reflect;
- // FIXME: security checks.
+ memberAccessCheck(Member::PUBLIC);
// This will overestimate the size we need.
jint count = _getMethods (NULL, 0);
@@ -696,12 +711,7 @@
jobject
java::lang::Class::newInstance (void)
{
- // FIXME: do accessibility checks here. There currently doesn't
- // seem to be any way to do these.
- // FIXME: we special-case one check here just to pass a Plum Hall
- // test. Once access checking is implemented, remove this.
- if (this == &java::lang::Class::class$)
- throw new java::lang::IllegalAccessException;
+ memberAccessCheck(java::lang::reflect::Member::PUBLIC);
if (isPrimitive ()
|| isInterface ()
@@ -1744,7 +1754,26 @@
{
for (int i = 0; i < klass->vtable_method_count; ++i)
if (! flags[i])
- // FIXME: messsage.
- throw new java::lang::AbstractMethodError ();
+ {
+ using namespace java::lang;
+ while (klass != NULL)
+ {
+ for (int j = 0; j < klass->method_count; ++j)
+ {
+ if (klass->methods[i].index == i)
+ {
+ StringBuffer *buf = new StringBuffer ();
+ buf->append (_Jv_NewStringUtf8Const (klass->methods[i].name));
+ buf->append ((jchar) ' ');
+ buf->append (_Jv_NewStringUtf8Const (klass->methods[i].signature));
+ throw new AbstractMethodError (buf->toString ());
+ }
+ }
+ klass = klass->getSuperclass ();
+ }
+ // Couldn't find the name, which is weird.
+ // But we still must throw the error.
+ throw new AbstractMethodError ();
+ }
}
}
Index: java/lang/reflect/Field.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/Field.java,v
retrieving revision 1.8
diff -u -r1.8 Field.java
--- java/lang/reflect/Field.java 24 Oct 2001 18:06:48 -0000 1.8
+++ java/lang/reflect/Field.java 21 Jul 2003 01:44:51 -0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation
This file is part of libgcj.
@@ -12,15 +12,6 @@
* @author Per Bothner <bothner@cygnus.com>
* @date September 1998; February 1999.
*/
-/* Status: Mostly implemented.
- * However, access checks are not implemented. See natField.cc for
- * _Jv_CheckFieldAccessibility as well as the missing getCaller.
- * Note that the idea is to have to compiler convert calls to
- * setXXX(...) and getXXX(...) to setXXX(CALLER, ...) and getXXX(CALLER, ...),
- * where CALLER is reference to the class that contains the calls to
- * setXXX or getXXX. This is easy for the compiler, and replaces
- * expensive stack and table searching with a constant.
- */
public final class Field extends AccessibleObject implements Member
{
@@ -39,12 +30,12 @@
}
public boolean equals (Object fld)
- {
- if (! (fld instanceof Field))
- return false;
- Field f = (Field) fld;
- return declaringClass == f.declaringClass && offset == f.offset;
- }
+ {
+ if (! (fld instanceof Field))
+ return false;
+ Field f = (Field) fld;
+ return declaringClass == f.declaringClass && offset == f.offset;
+ }
public Class getDeclaringClass ()
{
@@ -61,11 +52,6 @@
{
return (declaringClass.hashCode() ^ offset);
}
-
- // The idea is that the compiler will magically translate
- // fld.getShort(obj) to fld.getShort(THISCLASS, obj).
- // This makes checking assessiblity more efficient,
- // since we don't have to do any stack-walking.
public boolean getBoolean (Object obj)
throws IllegalArgumentException, IllegalAccessException
Index: java/lang/reflect/natArray.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/natArray.cc,v
retrieving revision 1.11
diff -u -r1.11 natArray.cc
--- java/lang/reflect/natArray.cc 2 Oct 2001 13:44:32 -0000 1.11
+++ java/lang/reflect/natArray.cc 21 Jul 2003 01:44:51 -0000
@@ -1,6 +1,6 @@
// natField.cc - Implementation of java.lang.reflect.Field native methods.
-/* Copyright (C) 1999, 2000, 2001 Free Software Foundation
+/* Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation
This file is part of libgcj.
@@ -15,6 +15,7 @@
#include <jvm.h>
#include <gcj/cni.h>
#include <java/lang/reflect/Array.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/IllegalArgumentException.h>
#include <java/lang/Byte.h>
#include <java/lang/Short.h>
@@ -38,8 +39,8 @@
return _Jv_NewPrimArray (componentType, length);
}
else
+ // FIXME: class loader?
return JvNewObjectArray (length, componentType, NULL);
-
}
jobject
@@ -52,10 +53,26 @@
jint* dims = elements (dimensions);
if (ndims == 1)
return newInstance (componentType, dims[0]);
+
+ gnu::gcj::runtime::StackTrace *t
+ = new gnu::gcj::runtime::StackTrace(4);
+ Class *caller = NULL;
+ ClassLoader *caller_loader = NULL;
+ try
+ {
+ for (int i = 1; !caller; i++)
+ {
+ caller = t->classAt (i);
+ }
+ caller_loader = caller->getClassLoaderInternal();
+ }
+ catch (::java::lang::ArrayIndexOutOfBoundsException *e)
+ {
+ }
+
jclass arrayType = componentType;
- for (int i = 0; i < ndims; i++) // FIXME 2nd arg should
- // be "current" loader
- arrayType = _Jv_GetArrayClass (arrayType, 0);
+ for (int i = 0; i < ndims; i++)
+ arrayType = _Jv_GetArrayClass (arrayType, caller_loader);
return _Jv_NewMultiArray (arrayType, ndims, dims);
}
@@ -343,8 +360,10 @@
void
java::lang::reflect::Array::set (jobject array, jint index,
- jobject value, jclass elType)
+ jobject value, jclass elType)
{
+ // We don't have to call getElementType here, or check INDEX,
+ // because it was already done in the Java wrapper.
if (! _Jv_IsInstanceOf (value, elType))
throw new java::lang::IllegalArgumentException;
elements ((jobjectArray) array) [index] = value;
Index: java/lang/reflect/natConstructor.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/natConstructor.cc,v
retrieving revision 1.8
diff -u -r1.8 natConstructor.cc
--- java/lang/reflect/natConstructor.cc 27 Aug 2002 23:57:17 -0000 1.8
+++ java/lang/reflect/natConstructor.cc 21 Jul 2003 01:44:51 -0000
@@ -1,6 +1,6 @@
// natConstructor.cc - Native code for Constructor class.
-/* Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation
+/* Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj.
@@ -13,6 +13,8 @@
#include <gcj/cni.h>
#include <jvm.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
+#include <java/lang/IllegalAccessException.h>
#include <java/lang/reflect/Constructor.h>
#include <java/lang/reflect/Method.h>
#include <java/lang/reflect/InvocationTargetException.h>
@@ -45,6 +47,24 @@
{
if (parameter_types == NULL)
getType ();
+
+ gnu::gcj::runtime::StackTrace *t
+ = new gnu::gcj::runtime::StackTrace(4);
+ Class *caller = NULL;
+ try
+ {
+ for (int i = 1; !caller; i++)
+ {
+ caller = t->classAt (i);
+ }
+ }
+ catch (::java::lang::ArrayIndexOutOfBoundsException *e)
+ {
+ }
+
+ if (! isAccessible() && ! _Jv_CheckAccess(caller, declaringClass,
+ declaringClass->getModifiers()))
+ throw new java::lang::IllegalAccessException;
using namespace java::lang::reflect;
if (Modifier::isAbstract (declaringClass->getModifiers()))
Index: java/lang/reflect/natField.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/natField.cc,v
retrieving revision 1.12
diff -u -r1.12 natField.cc
--- java/lang/reflect/natField.cc 7 Nov 2002 17:57:09 -0000 1.12
+++ java/lang/reflect/natField.cc 21 Jul 2003 01:44:51 -0000
@@ -1,6 +1,6 @@
// natField.cc - Implementation of java.lang.reflect.Field native methods.
-/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation
This file is part of libgcj.
@@ -15,6 +15,7 @@
#include <jvm.h>
#include <java/lang/reflect/Field.h>
#include <java/lang/reflect/Modifier.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/IllegalArgumentException.h>
#include <java/lang/IllegalAccessException.h>
#include <java/lang/NullPointerException.h>
@@ -46,31 +47,36 @@
{
jfieldID fld = _Jv_FromReflectedField (this);
JvSynchronize sync (declaringClass);
- _Jv_ResolveField (fld, declaringClass->getClassLoader ());
+ _Jv_ResolveField (fld, declaringClass->getClassLoaderInternal ());
return fld->type;
}
-static void
-_Jv_CheckFieldAccessibility (jfieldID /*fld*/, jclass /*caller*/)
-{
-#if 0
- if (caller == NULL)
- caller = getCaller();
-#endif
-#if 0
- _Jv_ushort flags = fld->getModifiers();
- check accesss;
-#endif
-}
-
static void*
getAddr (java::lang::reflect::Field* field, jclass caller, jobject obj)
{
+ // FIXME: we know CALLER is NULL here. At one point we planned to
+ // have the compiler insert the caller as a hidden argument in some
+ // calls. However, we never implemented that, so we have to find
+ // the caller by hand instead.
+ gnu::gcj::runtime::StackTrace *t
+ = new gnu::gcj::runtime::StackTrace(4);
+ try
+ {
+ for (int i = 1; !caller; i++)
+ {
+ caller = t->classAt (i);
+ }
+ }
+ catch (::java::lang::ArrayIndexOutOfBoundsException *e)
+ {
+ }
+
jfieldID fld = _Jv_FromReflectedField (field);
_Jv_ushort flags = fld->getModifiers();
- if (! (flags & java::lang::reflect::Modifier::PUBLIC)
- && ! field->isAccessible ())
- _Jv_CheckFieldAccessibility (fld, caller);
+ if (! field->isAccessible ()
+ && ! _Jv_CheckAccess (caller, field->getDeclaringClass(), flags))
+ throw new java::lang::IllegalAccessException;
+
if (flags & java::lang::reflect::Modifier::STATIC)
{
jclass fldClass = field->getDeclaringClass ();
Index: java/lang/reflect/natMethod.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/natMethod.cc,v
retrieving revision 1.31
diff -u -r1.31 natMethod.cc
--- java/lang/reflect/natMethod.cc 28 Feb 2003 17:26:29 -0000 1.31
+++ java/lang/reflect/natMethod.cc 21 Jul 2003 01:44:51 -0000
@@ -1,6 +1,6 @@
// natMethod.cc - Native code for Method class.
-/* Copyright (C) 1998, 1999, 2000, 2001 , 2002 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001 , 2002, 2003 Free Software Foundation
This file is part of libgcj.
@@ -30,6 +30,7 @@
#include <java/lang/Double.h>
#include <java/lang/IllegalArgumentException.h>
#include <java/lang/NullPointerException.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/Class.h>
#include <gcj/method.h>
#include <gnu/gcj/RawData.h>
@@ -142,19 +143,33 @@
if (parameter_types == NULL)
getType ();
+ gnu::gcj::runtime::StackTrace *t
+ = new gnu::gcj::runtime::StackTrace(4);
+ Class *caller = NULL;
+ try
+ {
+ for (int i = 1; !caller; i++)
+ {
+ caller = t->classAt (i);
+ }
+ }
+ catch (::java::lang::ArrayIndexOutOfBoundsException *e)
+ {
+ }
+
jmethodID meth = _Jv_FromReflectedMethod (this);
+ jclass klass;
if (! java::lang::reflect::Modifier::isStatic(meth->accflags))
{
- jclass k = obj ? obj->getClass() : NULL;
if (! obj)
throw new java::lang::NullPointerException;
- if (! declaringClass->isAssignableFrom(k))
+ klass = obj->getClass();
+ if (! declaringClass->isAssignableFrom(klass))
throw new java::lang::IllegalArgumentException;
- // FIXME: access checks.
// Find the possibly overloaded method based on the runtime type
// of the object.
- meth = _Jv_LookupDeclaredMethod (k, meth->name, meth->signature);
+ meth = _Jv_LookupDeclaredMethod (klass, meth->name, meth->signature);
}
else
{
@@ -162,8 +177,12 @@
// here and not in _Jv_CallAnyMethodA because JNI initializes a
// class whenever a method lookup is done.
_Jv_InitClass (declaringClass);
+ klass = declaringClass;
}
+ if (! isAccessible() && ! _Jv_CheckAccess(caller, klass, meth->accflags))
+ throw new IllegalArgumentException;
+
return _Jv_CallAnyMethodA (obj, return_type, meth, false,
parameter_types, args);
}
@@ -207,7 +226,7 @@
jclass *elts = elements (exception_types);
for (int i = 0; i < count; ++i)
elts[i] = _Jv_FindClass (method->throws[i],
- declaringClass->getClassLoader ());
+ declaringClass->getClassLoaderInternal ());
}
void
@@ -218,7 +237,7 @@
{
_Jv_Utf8Const* sig = method->signature;
- java::lang::ClassLoader *loader = declaringClass->getClassLoader();
+ java::lang::ClassLoader *loader = declaringClass->getClassLoaderInternal();
char *ptr = sig->data;
int numArgs = 0;
/* First just count the number of parameters. */
@@ -344,19 +363,11 @@
jclass *paramelts = elements (parameter_types);
- // FIXME: at some point the compiler is going to add extra arguments
- // to some functions. In particular we are going to do this for
- // handling access checks in reflection. We must add these hidden
- // arguments here.
-
// Special case for the `this' argument of a constructor. Note that
// the JDK 1.2 docs specify that the new object must be allocated
// before argument conversions are done.
if (is_constructor)
- {
- // FIXME: must special-case String, arrays, maybe others here.
- obj = JvAllocObject (return_type);
- }
+ obj = JvAllocObject (return_type);
const int size_per_arg = sizeof(jvalue);
ffi_cif cif;
@@ -488,8 +499,6 @@
JArray<jclass> *parameter_types,
jobjectArray args)
{
- // FIXME: access checks.
-
if (parameter_types->length == 0 && args == NULL)
{
// The JDK accepts this, so we do too.