Name: rlT66838 Date: 08/13/97


I am using JDK 1.1.3 with the JDK 1.1.3 VM on NT 4.0.
I am trying to use invoke() to call hasMoreElements()
on the Enumeration (java.util.VectorEnumerator) that I
obtained from a Vector. I am getting an llegalAccessException,
although I clearly have access to call this function
through the Enumeration interface.
I believe that the problem is related to the fact that
the class VectorEnumerator is not accessible to me,
even though I can call its public functions when it
is passed to me as an Enumeration. I think that invoke()
may be checking to see if the VectorEnumeration class
is accessible, and complaining when it discovers that
it is not. I don't know if this is true (invoke() is native,
so I can't check the source.)

(Speculation follows: ) If this is the problem, I recommend modifying
java.lang.reflect.Method.invokeinvoke(Object obj, Object args[])
so that it only checks to see if I have access to
the class in which Method is defined if the
Method is static, and if it is non-static then
it just checks the function that I am calling,
to better mimic the security behaviour that the VM
uses for a regular function invocation.
(End of speculation.)

Sample code is below.



import java.util.*;
import java.lang.reflect.*;
import java.io.*;

// Tries to use the reflection APIs to invoke Enumeration.hasMoreElements(),
// and fails miserably. Sample output:
//
// >java test
// java.lang.IllegalAccessException: java/util/VectorEnumerator
// at test.main(test.java:46)

class test
{
final static boolean HACK = false;

public static void main(String[] argc)
throws NoSuchMethodException,
IllegalAccessException,
InvocationTargetException
{
Vector myVector = new Vector();
//foo myFoo = new foo();

Enumeration myEnum;
if (HACK)
myEnum = new enumerationWrapper(myVector.elements());
else
myEnum = myVector.elements();

// Create the Vector & Enumeration
// If HACK, then we wrap it with out (accessible) Enumeration

Class[] theArgTypes = new Class[0];
// hasMoreElements() takes 0 parameters

Class enumClass = myEnum.getClass();
// get the class

        Method hasMoreElements =
enumClass.getDeclaredMethod("hasMoreElements", theArgTypes);
// create the Method from the class & param list

Object[] theArgs = new Object[0];
// create the parameters (there are none of them)

Object result = hasMoreElements.invoke(myEnum, theArgs);
// try to invoke Enumeration.hasMoreElements()

System.out.println("m_Method.invoke(myEnum, theArgs); == " + result);
// we never get here unless HACK == true
}

public final static class enumerationWrapper implements Enumeration
{
Enumeration java_util_VectorEnumerator;
// The Enumeration we're wrapping

public enumerationWrapper(Enumeration java_util_VectorEnumerator)
{
this.java_util_VectorEnumerator = java_util_VectorEnumerator;
}

public boolean hasMoreElements()
{
return java_util_VectorEnumerator.hasMoreElements();
}

public Object nextElement()
{
return java_util_VectorEnumerator.nextElement();
}
}

}



======================================================================