/** Handy class full of static functions that don't belong in util.Utility for pure ORB reasons. */
public final class ORBUtility {
private ORBUtility() {}
private static ORBUtilSystemException wrapper = ORBUtilSystemException.get(CORBALogDomains.UTIL);
private static OMGSystemException omgWrapper = OMGSystemException.get(CORBALogDomains.UTIL);
private static StructMember[] members = null;
private static StructMember[] systemExceptionMembers(ORB orb) {
if (members == null) {
members = new StructMember[3];
members[0] = new StructMember("id", orb.create_string_tc(0), null);
members[1] = new StructMember("minor", orb.get_primitive_tc(TCKind.tk_long), null);
members[2] = new StructMember("completed", orb.get_primitive_tc(TCKind.tk_long), null);
}
return members;
}
private static TypeCode getSystemExceptionTypeCode(ORB orb, String repID, String name) {
synchronized (TypeCode.class) {
return orb.create_exception_tc(repID, name, systemExceptionMembers(orb));
}
}
private static boolean isSystemExceptionTypeCode(TypeCode type, ORB orb) {
StructMember[] systemExceptionMembers = systemExceptionMembers(orb);
try {
return (type.kind().value() == TCKind._tk_except
&& type.member_count() == 3
&& type.member_type(0).equal(systemExceptionMembers[0].type)
&& type.member_type(1).equal(systemExceptionMembers[1].type)
&& type.member_type(2).equal(systemExceptionMembers[2].type));
} catch (BadKind ex) {
return false;
} catch (org.omg.CORBA.TypeCodePackage.Bounds ex) {
return false;
}
}
/**
* Static method for writing a CORBA standard exception to an Any.
*
* @param any The Any to write the SystemException into.
*/
public static void insertSystemException(SystemException ex, Any any) {
OutputStream out = any.create_output_stream();
ORB orb = (ORB) (out.orb());
String name = ex.getClass().getName();
String repID = ORBUtility.repositoryIdOf(name);
out.write_string(repID);
out.write_long(ex.minor);
out.write_long(ex.completed.value());
any.read_value(out.create_input_stream(), getSystemExceptionTypeCode(orb, repID, name));
}
public static SystemException extractSystemException(Any any) {
InputStream in = any.create_input_stream();
ORB orb = (ORB) (in.orb());
if (!isSystemExceptionTypeCode(any.type(), orb)) {
throw wrapper.unknownDsiSysex(CompletionStatus.COMPLETED_MAYBE);
}
return ORBUtility.readSystemException(in);
}
/** Return default ValueHandler */
public static ValueHandler createValueHandler() {
return Util.createValueHandler();
}
/**
* Returns true if it was accurately determined that the remote ORB is a foreign (non-JavaSoft)
* ORB. Note: If passed the ORBSingleton, this will return false.
*/
public static boolean isForeignORB(ORB orb) {
if (orb == null) return false;
try {
return orb.getORBVersion().equals(ORBVersionFactory.getFOREIGN());
} catch (SecurityException se) {
return false;
}
}
/**
* Unmarshal a byte array to an integer. Assume the bytes are in BIGENDIAN order. i.e.
* array[offset] is the most-significant-byte and array[offset+3] is the least-significant-byte.
*
* @param array The array of bytes.
* @param offset The offset from which to start unmarshalling.
*/
public static int bytesToInt(byte[] array, int offset) {
int b1, b2, b3, b4;
b1 = (array[offset++] << 24) & 0xFF000000;
b2 = (array[offset++] << 16) & 0x00FF0000;
b3 = (array[offset++] << 8) & 0x0000FF00;
b4 = (array[offset++] << 0) & 0x000000FF;
return (b1 | b2 | b3 | b4);
}
/**
* Marshal an integer to a byte array. The bytes are in BIGENDIAN order. i.e. array[offset] is the
* most-significant-byte and array[offset+3] is the least-significant-byte.
*
* @param array The array of bytes.
* @param offset The offset from which to start marshalling.
*/
public static void intToBytes(int value, byte[] array, int offset) {
array[offset++] = (byte) ((value >>> 24) & 0xFF);
array[offset++] = (byte) ((value >>> 16) & 0xFF);
array[offset++] = (byte) ((value >>> 8) & 0xFF);
array[offset++] = (byte) ((value >>> 0) & 0xFF);
}
/** Converts an Ascii Character into Hexadecimal digit */
public static int hexOf(char x) {
int val;
val = x - '0';
if (val >= 0 && val <= 9) return val;
val = (x - 'a') + 10;
if (val >= 10 && val <= 15) return val;
val = (x - 'A') + 10;
if (val >= 10 && val <= 15) return val;
throw wrapper.badHexDigit();
}
// method moved from util.Utility
/**
* Static method for writing a CORBA standard exception to a stream.
*
* @param strm The OutputStream to use for marshaling.
*/
public static void writeSystemException(SystemException ex, OutputStream strm) {
String s;
s = repositoryIdOf(ex.getClass().getName());
strm.write_string(s);
strm.write_long(ex.minor);
strm.write_long(ex.completed.value());
}
/**
* Static method for reading a CORBA standard exception from a stream.
*
* @param strm The InputStream to use for unmarshaling.
*/
public static SystemException readSystemException(InputStream strm) {
try {
String name = classNameOf(strm.read_string());
SystemException ex = (SystemException) ORBClassLoader.loadClass(name).newInstance();
ex.minor = strm.read_long();
ex.completed = CompletionStatus.from_int(strm.read_long());
return ex;
} catch (Exception ex) {
throw wrapper.unknownSysex(CompletionStatus.COMPLETED_MAYBE, ex);
}
}
/**
* Get the class name corresponding to a particular repository Id. This is used by the system to
* unmarshal (instantiate) the appropriate exception class for an marshaled as the value of its
* repository Id.
*
* @param repositoryId The repository Id for which we want a class name.
*/
public static String classNameOf(String repositoryId) {
String className = null;
className = (String) exceptionClassNames.get(repositoryId);
if (className == null) className = "org.omg.CORBA.UNKNOWN";
return className;
}
/**
* Return true if this repositoryId is a SystemException.
*
* @param repositoryId The repository Id to check.
*/
public static boolean isSystemException(String repositoryId) {
String className = null;
className = (String) exceptionClassNames.get(repositoryId);
if (className == null) return false;
else return true;
}
/** @return the Java serialization encoding version. */
public static byte getEncodingVersion(ORB orb, IOR ior) {
// Is Java serialization enabled?
// Check the JavaSerializationComponent (tagged component)
// in the IIOPProfile. If present, the peer ORB's GIOP is capable
// of using Java serialization instead of CDR serialization.
// In such a case, use Java serialization, iff the java serialization
// versions match.
if (orb.getORBData().isJavaSerializationEnabled()) {
IIOPProfile prof = ior.getProfile();
IIOPProfileTemplate profTemp = (IIOPProfileTemplate) prof.getTaggedProfileTemplate();
java.util.Iterator iter = profTemp.iteratorById(ORBConstants.TAG_JAVA_SERIALIZATION_ID);
if (iter.hasNext()) {
JavaSerializationComponent jc = (JavaSerializationComponent) iter.next();
byte jcVersion = jc.javaSerializationVersion();
if (jcVersion >= Message.JAVA_ENC_VERSION) {
return Message.JAVA_ENC_VERSION;
} else if (jcVersion > Message.CDR_ENC_VERSION) {
return jc.javaSerializationVersion();
} else {
// throw error?
// Since encodingVersion is <= 0 (CDR_ENC_VERSION).
}
}
}
return Message.CDR_ENC_VERSION; // default
}
/**
* Get the repository id corresponding to a particular class. This is used by the system to write
* the appropriate repository id for a system exception.
*
* @param name The class name of the system exception.
*/
public static String repositoryIdOf(String name) {
String id;
id = (String) exceptionRepositoryIds.get(name);
if (id == null) id = "IDL:omg.org/CORBA/UNKNOWN:1.0";
return id;
}
private static final Hashtable exceptionClassNames = new Hashtable();
private static final Hashtable exceptionRepositoryIds = new Hashtable();
static {
//
// construct repositoryId -> className hashtable
//
exceptionClassNames.put("IDL:omg.org/CORBA/BAD_CONTEXT:1.0", "org.omg.CORBA.BAD_CONTEXT");
exceptionClassNames.put("IDL:omg.org/CORBA/BAD_INV_ORDER:1.0", "org.omg.CORBA.BAD_INV_ORDER");
exceptionClassNames.put("IDL:omg.org/CORBA/BAD_OPERATION:1.0", "org.omg.CORBA.BAD_OPERATION");
exceptionClassNames.put("IDL:omg.org/CORBA/BAD_PARAM:1.0", "org.omg.CORBA.BAD_PARAM");
exceptionClassNames.put("IDL:omg.org/CORBA/BAD_TYPECODE:1.0", "org.omg.CORBA.BAD_TYPECODE");
exceptionClassNames.put("IDL:omg.org/CORBA/COMM_FAILURE:1.0", "org.omg.CORBA.COMM_FAILURE");
exceptionClassNames.put(
"IDL:omg.org/CORBA/DATA_CONVERSION:1.0", "org.omg.CORBA.DATA_CONVERSION");
exceptionClassNames.put("IDL:omg.org/CORBA/IMP_LIMIT:1.0", "org.omg.CORBA.IMP_LIMIT");
exceptionClassNames.put("IDL:omg.org/CORBA/INTF_REPOS:1.0", "org.omg.CORBA.INTF_REPOS");
exceptionClassNames.put("IDL:omg.org/CORBA/INTERNAL:1.0", "org.omg.CORBA.INTERNAL");
exceptionClassNames.put("IDL:omg.org/CORBA/INV_FLAG:1.0", "org.omg.CORBA.INV_FLAG");
exceptionClassNames.put("IDL:omg.org/CORBA/INV_IDENT:1.0", "org.omg.CORBA.INV_IDENT");
exceptionClassNames.put("IDL:omg.org/CORBA/INV_OBJREF:1.0", "org.omg.CORBA.INV_OBJREF");
exceptionClassNames.put("IDL:omg.org/CORBA/MARSHAL:1.0", "org.omg.CORBA.MARSHAL");
exceptionClassNames.put("IDL:omg.org/CORBA/NO_MEMORY:1.0", "org.omg.CORBA.NO_MEMORY");
exceptionClassNames.put("IDL:omg.org/CORBA/FREE_MEM:1.0", "org.omg.CORBA.FREE_MEM");
exceptionClassNames.put("IDL:omg.org/CORBA/NO_IMPLEMENT:1.0", "org.omg.CORBA.NO_IMPLEMENT");
exceptionClassNames.put("IDL:omg.org/CORBA/NO_PERMISSION:1.0", "org.omg.CORBA.NO_PERMISSION");
exceptionClassNames.put("IDL:omg.org/CORBA/NO_RESOURCES:1.0", "org.omg.CORBA.NO_RESOURCES");
exceptionClassNames.put("IDL:omg.org/CORBA/NO_RESPONSE:1.0", "org.omg.CORBA.NO_RESPONSE");
exceptionClassNames.put("IDL:omg.org/CORBA/OBJ_ADAPTER:1.0", "org.omg.CORBA.OBJ_ADAPTER");
exceptionClassNames.put("IDL:omg.org/CORBA/INITIALIZE:1.0", "org.omg.CORBA.INITIALIZE");
exceptionClassNames.put("IDL:omg.org/CORBA/PERSIST_STORE:1.0", "org.omg.CORBA.PERSIST_STORE");
exceptionClassNames.put("IDL:omg.org/CORBA/TRANSIENT:1.0", "org.omg.CORBA.TRANSIENT");
exceptionClassNames.put("IDL:omg.org/CORBA/UNKNOWN:1.0", "org.omg.CORBA.UNKNOWN");
exceptionClassNames.put(
"IDL:omg.org/CORBA/OBJECT_NOT_EXIST:1.0", "org.omg.CORBA.OBJECT_NOT_EXIST");
// SystemExceptions from OMG Transactions Service Spec
exceptionClassNames.put(
"IDL:omg.org/CORBA/INVALID_TRANSACTION:1.0", "org.omg.CORBA.INVALID_TRANSACTION");
exceptionClassNames.put(
"IDL:omg.org/CORBA/TRANSACTION_REQUIRED:1.0", "org.omg.CORBA.TRANSACTION_REQUIRED");
exceptionClassNames.put(
"IDL:omg.org/CORBA/TRANSACTION_ROLLEDBACK:1.0", "org.omg.CORBA.TRANSACTION_ROLLEDBACK");
// from portability RTF 98-07-01.txt
exceptionClassNames.put("IDL:omg.org/CORBA/INV_POLICY:1.0", "org.omg.CORBA.INV_POLICY");
// from orbrev/00-09-01 (CORBA 2.4 Draft Specification)
exceptionClassNames.put(
"IDL:omg.org/CORBA/TRANSACTION_UNAVAILABLE:1.0", "org.omg.CORBA.TRANSACTION_UNAVAILABLE");
exceptionClassNames.put(
"IDL:omg.org/CORBA/TRANSACTION_MODE:1.0", "org.omg.CORBA.TRANSACTION_MODE");
// Exception types introduced between CORBA 2.4 and 3.0
exceptionClassNames.put(
"IDL:omg.org/CORBA/CODESET_INCOMPATIBLE:1.0", "org.omg.CORBA.CODESET_INCOMPATIBLE");
exceptionClassNames.put("IDL:omg.org/CORBA/REBIND:1.0", "org.omg.CORBA.REBIND");
exceptionClassNames.put("IDL:omg.org/CORBA/TIMEOUT:1.0", "org.omg.CORBA.TIMEOUT");
exceptionClassNames.put("IDL:omg.org/CORBA/BAD_QOS:1.0", "org.omg.CORBA.BAD_QOS");
// Exception types introduced in CORBA 3.0
exceptionClassNames.put(
"IDL:omg.org/CORBA/INVALID_ACTIVITY:1.0", "org.omg.CORBA.INVALID_ACTIVITY");
exceptionClassNames.put(
"IDL:omg.org/CORBA/ACTIVITY_COMPLETED:1.0", "org.omg.CORBA.ACTIVITY_COMPLETED");
exceptionClassNames.put(
"IDL:omg.org/CORBA/ACTIVITY_REQUIRED:1.0", "org.omg.CORBA.ACTIVITY_REQUIRED");
//
// construct className -> repositoryId hashtable
//
Enumeration keys = exceptionClassNames.keys();
java.lang.Object s;
String rId;
String cName;
try {
while (keys.hasMoreElements()) {
s = keys.nextElement();
rId = (String) s;
cName = (String) exceptionClassNames.get(rId);
exceptionRepositoryIds.put(cName, rId);
}
} catch (NoSuchElementException e) {
}
}
/**
* Parse a version string such as "1.1.6" or "jdk1.2fcs" into a version array of integers {1, 1,
* 6} or {1, 2}. A string of "n." or "n..m" is equivalent to "n.0" or "n.0.m" respectively.
*/
public static int[] parseVersion(String version) {
if (version == null) return new int[0];
char[] s = version.toCharArray();
// find the maximum span of the string "n.n.n..." where n is an integer
int start = 0;
for (; start < s.length && (s[start] < '0' || s[start] > '9'); ++start)
if (start == s.length) // no digit found
return new int[0];
int end = start + 1;
int size = 1;
for (; end < s.length; ++end)
if (s[end] == '.') ++size;
else if (s[end] < '0' || s[end] > '9') break;
int[] val = new int[size];
for (int i = 0; i < size; ++i) {
int dot = version.indexOf('.', start);
if (dot == -1 || dot > end) dot = end;
if (start >= dot) // cases like "n." or "n..m"
val[i] = 0; // convert equivalent to "n.0" or "n.0.m"
else val[i] = Integer.parseInt(version.substring(start, dot));
start = dot + 1;
}
return val;
}
/**
* Compare two version arrays. Return 1, 0 or -1 if v1 is greater than, equal to, or less than v2.
*/
public static int compareVersion(int[] v1, int[] v2) {
if (v1 == null) v1 = new int[0];
if (v2 == null) v2 = new int[0];
for (int i = 0; i < v1.length; ++i) {
if (i >= v2.length || v1[i] > v2[i]) // v1 is longer or greater than v2
return 1;
if (v1[i] < v2[i]) return -1;
}
return v1.length == v2.length ? 0 : -1;
}
/**
* Compare two version strings. Return 1, 0 or -1 if v1 is greater than, equal to, or less than
* v2.
*/
public static synchronized int compareVersion(String v1, String v2) {
return compareVersion(parseVersion(v1), parseVersion(v2));
}
private static String compressClassName(String name) {
// Note that this must end in . in order to be renamed correctly.
String prefix = "com.sun.corba.se.";
if (name.startsWith(prefix)) {
return "(ORB)." + name.substring(prefix.length());
} else return name;
}
// Return a compressed representation of the thread name. This is particularly
// useful on the server side, where there are many SelectReaderThreads, and
// we need a short unambiguous name for such threads.
public static String getThreadName(Thread thr) {
if (thr == null) return "null";
// This depends on the formatting in SelectReaderThread and CorbaConnectionImpl.
// Pattern for SelectReaderThreads:
// SelectReaderThread CorbaConnectionImpl[ <host> <post> <state>]
// Any other pattern in the Thread's name is just returned.
String name = thr.getName();
StringTokenizer st = new StringTokenizer(name);
int numTokens = st.countTokens();
if (numTokens != 5) return name;
String[] tokens = new String[numTokens];
for (int ctr = 0; ctr < numTokens; ctr++) tokens[ctr] = st.nextToken();
if (!tokens[0].equals("SelectReaderThread")) return name;
return "SelectReaderThread[" + tokens[2] + ":" + tokens[3] + "]";
}
private static String formatStackTraceElement(StackTraceElement ste) {
return compressClassName(ste.getClassName())
+ "."
+ ste.getMethodName()
+ (ste.isNativeMethod()
? "(Native Method)"
: (ste.getFileName() != null && ste.getLineNumber() >= 0
? "(" + ste.getFileName() + ":" + ste.getLineNumber() + ")"
: (ste.getFileName() != null
? "(" + ste.getFileName() + ")"
: "(Unknown Source)")));
}
private static void printStackTrace(StackTraceElement[] trace) {
System.out.println(" Stack Trace:");
// print the stack trace, ommitting the zeroth element, which is
// always this method.
for (int ctr = 1; ctr < trace.length; ctr++) {
System.out.print(" >");
System.out.println(formatStackTraceElement(trace[ctr]));
}
}
//
// Implements all dprint calls in this package.
//
public static synchronized void dprint(java.lang.Object obj, String msg) {
System.out.println(
compressClassName(obj.getClass().getName())
+ "("
+ getThreadName(Thread.currentThread())
+ "): "
+ msg);
}
public static synchronized void dprint(String className, String msg) {
System.out.println(
compressClassName(className) + "(" + getThreadName(Thread.currentThread()) + "): " + msg);
}
public synchronized void dprint(String msg) {
ORBUtility.dprint(this, msg);
}
public static synchronized void dprintTrace(Object obj, String msg) {
ORBUtility.dprint(obj, msg);
Throwable thr = new Throwable();
printStackTrace(thr.getStackTrace());
}
public static synchronized void dprint(java.lang.Object caller, String msg, Throwable t) {
System.out.println(
compressClassName(caller.getClass().getName())
+ '('
+ Thread.currentThread()
+ "): "
+ msg);
if (t != null) printStackTrace(t.getStackTrace());
}
public static String[] concatenateStringArrays(String[] arr1, String[] arr2) {
String[] result = new String[arr1.length + arr2.length];
for (int ctr = 0; ctr < arr1.length; ctr++) result[ctr] = arr1[ctr];
for (int ctr = 0; ctr < arr2.length; ctr++) result[ctr + arr1.length] = arr2[ctr];
return result;
}
/**
* Throws the CORBA equivalent of a java.io.NotSerializableException
*
* <p>Duplicated from util/Utility for Pure ORB reasons. There are two reasons for this:
*
* <p>1) We can't introduce dependencies on the util version from outside of the io/util packages
* since it will not exist in the pure ORB build running on JDK 1.3.x.
*
* <p>2) We need to pick up the correct minor code from OMGSystemException.
*/
public static void throwNotSerializableForCorba(String className) {
throw omgWrapper.notSerializable(CompletionStatus.COMPLETED_MAYBE, className);
}
/** Returns the maximum stream format version supported by our ValueHandler. */
public static byte getMaxStreamFormatVersion() {
ValueHandler vh = Util.createValueHandler();
if (!(vh instanceof javax.rmi.CORBA.ValueHandlerMultiFormat))
return ORBConstants.STREAM_FORMAT_VERSION_1;
else return ((ValueHandlerMultiFormat) vh).getMaximumStreamFormatVersion();
}
public static CorbaClientDelegate makeClientDelegate(IOR ior) {
ORB orb = ior.getORB();
CorbaContactInfoList ccil = orb.getCorbaContactInfoListFactory().create(ior);
CorbaClientDelegate del = orb.getClientDelegateFactory().create(ccil);
return del;
}
/** This method is used to create untyped object references. */
public static org.omg.CORBA.Object makeObjectReference(IOR ior) {
CorbaClientDelegate del = makeClientDelegate(ior);
org.omg.CORBA.Object objectImpl = new CORBAObjectImpl();
StubAdapter.setDelegate(objectImpl, del);
return objectImpl;
}
/**
* This method obtains an IOR from a CORBA object reference. It will return null if obj is a local
* object, a null object, or an object implemented by a different ORB. It will throw BAD_OPERATION
* if obj is an unconnected RMI-IIOP object.
*
* @return IOR the IOR that represents this objref. This will never be null.
* @exception BAD_OPERATION (from oi._get_delegate) if obj is a normal objref, but does not have a
* delegate set.
* @exception BAD_PARAM if obj is a local object, or else was created by a foreign ORB.
*/
public static IOR getIOR(org.omg.CORBA.Object obj) {
if (obj == null) throw wrapper.nullObjectReference();
IOR ior = null;
if (StubAdapter.isStub(obj)) {
org.omg.CORBA.portable.Delegate del = StubAdapter.getDelegate(obj);
if (del instanceof CorbaClientDelegate) {
CorbaClientDelegate cdel = (CorbaClientDelegate) del;
ContactInfoList cil = cdel.getContactInfoList();
if (cil instanceof CorbaContactInfoList) {
CorbaContactInfoList ccil = (CorbaContactInfoList) cil;
ior = ccil.getTargetIOR();
if (ior == null) throw wrapper.nullIor();
return ior;
} else {
// This is our code, but the ContactInfoList is not a
// CorbaContactInfoList. This should not happen, because
// we are in the CORBA application of the DCSA framework.
// This is a coding error, and thus an INTERNAL exception
// should be thrown.
// XXX needs minor code
throw new INTERNAL();
}
}
// obj is implemented by a foreign ORB, because the Delegate is not a
// ClientDelegate.
// XXX this case could be handled by marshalling and
// unmarshalling. However, object_to_string cannot be used
// here, as it is implemented with getIOR. Note that this
// will require access to an ORB, so that we can create streams
// as needed. The ORB is available simply as io._orb().
throw wrapper.objrefFromForeignOrb();
} else throw wrapper.localObjectNotAllowed();
}
/**
* Obtains an IOR for the object reference obj, first connecting it to the ORB if necessary.
*
* @return IOR the IOR that represents this objref. This will never be null.
* @exception BAD_OPERATION if the object could not be connected, if a connection attempt was
* needed.
* @exception BAD_PARAM if obj is a local object, or else was created by a foreign ORB.
*/
public static IOR connectAndGetIOR(ORB orb, org.omg.CORBA.Object obj) {
IOR result;
try {
result = getIOR(obj);
} catch (BAD_OPERATION bop) {
if (StubAdapter.isStub(obj)) {
try {
StubAdapter.connect(obj, orb);
} catch (java.rmi.RemoteException exc) {
throw wrapper.connectingServant(exc);
}
} else {
orb.connect(obj);
}
result = getIOR(obj);
}
return result;
}
public static String operationNameAndRequestId(CorbaMessageMediator m) {
return "op/" + m.getOperationName() + " id/" + m.getRequestId();
}
public static boolean isPrintable(char c) {
if (Character.isJavaIdentifierStart(c)) {
// Letters and $ _
return true;
}
if (Character.isDigit(c)) {
return true;
}
switch (Character.getType(c)) {
case Character.MODIFIER_SYMBOL:
return true; // ` ^
case Character.DASH_PUNCTUATION:
return true; // -
case Character.MATH_SYMBOL:
return true; // = ~ + | < >
case Character.OTHER_PUNCTUATION:
return true; // !@#%&*;':",./?
case Character.START_PUNCTUATION:
return true; // ( [ {
case Character.END_PUNCTUATION:
return true; // ) ] }
}
return false;
}
public static String getClassSecurityInfo(final Class cl) {
// Returns a String which looks similar to:
// PermissionCollection java.security.Permissions@1053693 ...
// (java.io.FilePermission <<ALL FILES>> ....)
// (java.io.FilePermission /export0/sunwappserv/lib/- ...)
// ... other permissions ...
// Domain ProtectionDomain (file:/export0/sunwappserv/lib-)
// java.security.Permissions@141fedb (
// (java.io.FilePermission <<ALL FILES>> ...)
// (java.io.FilePermission /var/tmp//- ...)
String result =
(String)
AccessController.doPrivileged(
new PrivilegedAction() {
public java.lang.Object run() {
StringBuffer sb = new StringBuffer(500);
ProtectionDomain pd = cl.getProtectionDomain();
Policy policy = Policy.getPolicy();
PermissionCollection pc = policy.getPermissions(pd);
sb.append("\nPermissionCollection ");
sb.append(pc.toString());
// Don't need to add 'Protection Domain' string, it's
// in ProtectionDomain.toString() already.
sb.append(pd.toString());
return sb.toString();
}
});
return result;
}
}
public abstract class InputStreamHook extends ObjectInputStream {
// These should be visible in all the nested classes
static final OMGSystemException omgWrapper = OMGSystemException.get(CORBALogDomains.RPC_ENCODING);
static final UtilSystemException utilWrapper =
UtilSystemException.get(CORBALogDomains.RPC_ENCODING);
private class HookGetFields extends ObjectInputStream.GetField {
private Map fields = null;
HookGetFields(Map fields) {
this.fields = fields;
}
/**
* Get the ObjectStreamClass that describes the fields in the stream.
*
* <p>REVISIT! This doesn't work since we have our own ObjectStreamClass.
*/
public java.io.ObjectStreamClass getObjectStreamClass() {
return null;
}
/** Return true if the named field is defaulted and has no value in this stream. */
public boolean defaulted(String name) throws IOException, IllegalArgumentException {
return (!fields.containsKey(name));
}
/** Get the value of the named boolean field from the persistent field. */
public boolean get(String name, boolean defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Boolean) fields.get(name)).booleanValue();
}
/** Get the value of the named char field from the persistent fields. */
public char get(String name, char defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Character) fields.get(name)).charValue();
}
/** Get the value of the named byte field from the persistent fields. */
public byte get(String name, byte defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Byte) fields.get(name)).byteValue();
}
/** Get the value of the named short field from the persistent fields. */
public short get(String name, short defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Short) fields.get(name)).shortValue();
}
/** Get the value of the named int field from the persistent fields. */
public int get(String name, int defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Integer) fields.get(name)).intValue();
}
/** Get the value of the named long field from the persistent fields. */
public long get(String name, long defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Long) fields.get(name)).longValue();
}
/** Get the value of the named float field from the persistent fields. */
public float get(String name, float defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Float) fields.get(name)).floatValue();
}
/** Get the value of the named double field from the persistent field. */
public double get(String name, double defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return ((Double) fields.get(name)).doubleValue();
}
/** Get the value of the named Object field from the persistent field. */
public Object get(String name, Object defvalue) throws IOException, IllegalArgumentException {
if (defaulted(name)) return defvalue;
else return fields.get(name);
}
public String toString() {
return fields.toString();
}
}
public InputStreamHook() throws IOException {
super();
}
public void defaultReadObject() throws IOException, ClassNotFoundException, NotActiveException {
readObjectState.beginDefaultReadObject(this);
defaultReadObjectDelegate();
readObjectState.endDefaultReadObject(this);
}
public abstract void defaultReadObjectDelegate();
abstract void readFields(java.util.Map fieldToValueMap)
throws java.io.InvalidClassException, java.io.StreamCorruptedException,
ClassNotFoundException, java.io.IOException;
// See java.io.ObjectInputStream.GetField
// Remember that this is equivalent to defaultReadObject
// in RMI-IIOP
public ObjectInputStream.GetField readFields()
throws IOException, ClassNotFoundException, NotActiveException {
HashMap fieldValueMap = new HashMap();
// We were treating readFields same as defaultReadObject. It is
// incorrect if the state is readOptionalData. If this line
// is uncommented, it will throw a stream corrupted exception.
// _REVISIT_: The ideal fix would be to add a new state. In
// writeObject user may do one of the following
// 1. Call defaultWriteObject()
// 2. Put out optional fields
// 3. Call writeFields
// We have the state defined for (1) and (2) but not for (3), so
// we should ideally introduce a new state for 3 and have the
// beginDefaultReadObject do nothing.
// readObjectState.beginDefaultReadObject(this);
readFields(fieldValueMap);
readObjectState.endDefaultReadObject(this);
return new HookGetFields(fieldValueMap);
}
// The following is a State pattern implementation of what
// should be done when the sender's Serializable has a
// writeObject method. This was especially necessary for
// RMI-IIOP stream format version 2. Please see the
// state diagrams in the docs directory of the workspace.
//
// On the reader's side, the main factors are whether or not
// we have a readObject method and whether or not the
// sender wrote default data
protected void setState(ReadObjectState newState) {
readObjectState = newState;
}
protected abstract byte getStreamFormatVersion();
protected abstract org.omg.CORBA_2_3.portable.InputStream getOrbStream();
// Description of possible actions
protected static class ReadObjectState {
public void beginUnmarshalCustomValue(
InputStreamHook stream, boolean calledDefaultWriteObject, boolean hasReadObject)
throws IOException {}
public void endUnmarshalCustomValue(InputStreamHook stream) throws IOException {}
public void beginDefaultReadObject(InputStreamHook stream) throws IOException {}
public void endDefaultReadObject(InputStreamHook stream) throws IOException {}
public void readData(InputStreamHook stream) throws IOException {}
}
protected ReadObjectState readObjectState = DEFAULT_STATE;
protected static final ReadObjectState DEFAULT_STATE = new DefaultState();
protected static final ReadObjectState IN_READ_OBJECT_OPT_DATA =
new InReadObjectOptionalDataState();
protected static final ReadObjectState IN_READ_OBJECT_NO_MORE_OPT_DATA =
new InReadObjectNoMoreOptionalDataState();
protected static final ReadObjectState IN_READ_OBJECT_DEFAULTS_SENT =
new InReadObjectDefaultsSentState();
protected static final ReadObjectState NO_READ_OBJECT_DEFAULTS_SENT =
new NoReadObjectDefaultsSentState();
protected static final ReadObjectState IN_READ_OBJECT_REMOTE_NOT_CUSTOM_MARSHALED =
new InReadObjectRemoteDidNotUseWriteObjectState();
protected static final ReadObjectState IN_READ_OBJECT_PAST_DEFAULTS_REMOTE_NOT_CUSTOM =
new InReadObjectPastDefaultsRemoteDidNotUseWOState();
protected static class DefaultState extends ReadObjectState {
public void beginUnmarshalCustomValue(
InputStreamHook stream, boolean calledDefaultWriteObject, boolean hasReadObject)
throws IOException {
if (hasReadObject) {
if (calledDefaultWriteObject) stream.setState(IN_READ_OBJECT_DEFAULTS_SENT);
else {
try {
if (stream.getStreamFormatVersion() == 2)
((ValueInputStream) stream.getOrbStream()).start_value();
} catch (Exception e) {
// This will happen for Big Integer which uses
// writeFields in it's writeObject. We should be past
// start_value by now.
// NOTE: If we don't log any exception here we should
// be fine. If there is an error, it will be caught
// while reading the optional data.
}
stream.setState(IN_READ_OBJECT_OPT_DATA);
}
} else {
if (calledDefaultWriteObject) stream.setState(NO_READ_OBJECT_DEFAULTS_SENT);
else
// XXX I18N and logging needed.
throw new StreamCorruptedException("No default data sent");
}
}
}
// REVISIT. If a readObject exits here without reading
// default data, we won't skip it. This could be done automatically
// as in line 1492 in IIOPInputStream.
protected static class InReadObjectRemoteDidNotUseWriteObjectState extends ReadObjectState {
public void beginUnmarshalCustomValue(
InputStreamHook stream, boolean calledDefaultWriteObject, boolean hasReadObject) {
throw utilWrapper.badBeginUnmarshalCustomValue();
}
public void endDefaultReadObject(InputStreamHook stream) {
stream.setState(IN_READ_OBJECT_PAST_DEFAULTS_REMOTE_NOT_CUSTOM);
}
public void readData(InputStreamHook stream) {
stream.throwOptionalDataIncompatibleException();
}
}
protected static class InReadObjectPastDefaultsRemoteDidNotUseWOState extends ReadObjectState {
public void beginUnmarshalCustomValue(
InputStreamHook stream, boolean calledDefaultWriteObject, boolean hasReadObject) {
throw utilWrapper.badBeginUnmarshalCustomValue();
}
public void beginDefaultReadObject(InputStreamHook stream) throws IOException {
// XXX I18N and logging needed.
throw new StreamCorruptedException("Default data already read");
}
public void readData(InputStreamHook stream) {
stream.throwOptionalDataIncompatibleException();
}
}
protected void throwOptionalDataIncompatibleException() {
throw omgWrapper.rmiiiopOptionalDataIncompatible2();
}
protected static class InReadObjectDefaultsSentState extends ReadObjectState {
public void beginUnmarshalCustomValue(
InputStreamHook stream, boolean calledDefaultWriteObject, boolean hasReadObject) {
// This should never happen.
throw utilWrapper.badBeginUnmarshalCustomValue();
}
public void endUnmarshalCustomValue(InputStreamHook stream) {
// In stream format version 2, we can skip over
// the optional data this way. In stream format version 1,
// we will probably wind up with an error if we're
// unmarshaling a superclass.
if (stream.getStreamFormatVersion() == 2) {
((ValueInputStream) stream.getOrbStream()).start_value();
((ValueInputStream) stream.getOrbStream()).end_value();
}
stream.setState(DEFAULT_STATE);
}
public void endDefaultReadObject(InputStreamHook stream) throws IOException {
// Read the fake valuetype header in stream format version 2
if (stream.getStreamFormatVersion() == 2)
((ValueInputStream) stream.getOrbStream()).start_value();
stream.setState(IN_READ_OBJECT_OPT_DATA);
}
public void readData(InputStreamHook stream) throws IOException {
org.omg.CORBA.ORB orb = stream.getOrbStream().orb();
if ((orb == null) || !(orb instanceof com.sun.corba.se.spi.orb.ORB)) {
throw new StreamCorruptedException("Default data must be read first");
}
ORBVersion clientOrbVersion = ((com.sun.corba.se.spi.orb.ORB) orb).getORBVersion();
// Fix Date interop bug. For older versions of the ORB don't do
// anything for readData(). Before this used to throw
// StreamCorruptedException for older versions of the ORB where
// calledDefaultWriteObject always returns true.
if ((ORBVersionFactory.getPEORB().compareTo(clientOrbVersion) <= 0)
|| (clientOrbVersion.equals(ORBVersionFactory.getFOREIGN()))) {
// XXX I18N and logging needed.
throw new StreamCorruptedException("Default data must be read first");
}
}
}
protected static class InReadObjectOptionalDataState extends ReadObjectState {
public void beginUnmarshalCustomValue(
InputStreamHook stream, boolean calledDefaultWriteObject, boolean hasReadObject) {
// This should never happen.
throw utilWrapper.badBeginUnmarshalCustomValue();
}
public void endUnmarshalCustomValue(InputStreamHook stream) throws IOException {
if (stream.getStreamFormatVersion() == 2) {
((ValueInputStream) stream.getOrbStream()).end_value();
}
stream.setState(DEFAULT_STATE);
}
public void beginDefaultReadObject(InputStreamHook stream) throws IOException {
// XXX I18N and logging needed.
throw new StreamCorruptedException("Default data not sent or already read/passed");
}
}
protected static class InReadObjectNoMoreOptionalDataState extends InReadObjectOptionalDataState {
public void readData(InputStreamHook stream) throws IOException {
stream.throwOptionalDataIncompatibleException();
}
}
protected static class NoReadObjectDefaultsSentState extends ReadObjectState {
public void endUnmarshalCustomValue(InputStreamHook stream) throws IOException {
// Code should read default fields before calling this
if (stream.getStreamFormatVersion() == 2) {
((ValueInputStream) stream.getOrbStream()).start_value();
((ValueInputStream) stream.getOrbStream()).end_value();
}
stream.setState(DEFAULT_STATE);
}
}
}
/* */ public class FVDCodeBaseImpl extends _CodeBaseImplBase
/* */ {
/* 58 */ private static Hashtable fvds = new Hashtable();
/* *//* 62 */ private transient ORB orb = null;
/* */
/* 64 */ private transient OMGSystemException wrapper = OMGSystemException.get("rpc.encoding");
/* *//* 71 */ private transient ValueHandlerImpl vhandler = null;
/* */
/* */ void setValueHandler(ValueHandler paramValueHandler) /* */ {
/* 75 */ this.vhandler = ((ValueHandlerImpl) paramValueHandler);
/* */ }
/* */
/* */ public Repository get_ir() /* */ {
/* 80 */ return null;
/* */ }
/* */
/* */ public String implementation(String paramString) /* */ {
/* */ try
/* */ {
/* 88 */ if (this.vhandler == null) {
/* 89 */ this.vhandler = ValueHandlerImpl.getInstance(false);
/* */ }
/* */
/* 94 */ String str = Util.getCodebase(this.vhandler.getClassFromType(paramString));
/* 95 */ if (str == null) {
/* 96 */ return "";
/* */ }
/* 98 */ return str;
/* */ } catch (ClassNotFoundException localClassNotFoundException) {
/* 100 */ throw this.wrapper.missingLocalValueImpl(
CompletionStatus.COMPLETED_MAYBE, localClassNotFoundException);
/* */ }
/* */ }
/* */
/* */ public String[] implementations(String[] paramArrayOfString) /* */ {
/* 106 */ String[] arrayOfString = new String[paramArrayOfString.length];
/* */
/* 108 */ for (int i = 0; i < paramArrayOfString.length; i++) {
/* 109 */ arrayOfString[i] = implementation(paramArrayOfString[i]);
/* */ }
/* 111 */ return arrayOfString;
/* */ }
/* */
/* */ public FullValueDescription meta(String paramString) /* */ {
/* */ try {
/* 117 */ FullValueDescription localFullValueDescription =
(FullValueDescription) fvds.get(paramString);
/* */
/* 119 */ if (localFullValueDescription == null)
/* */ {
/* 122 */ if (this.vhandler == null) {
/* 123 */ this.vhandler = ValueHandlerImpl.getInstance(false);
/* */ }
/* */ try
/* */ {
/* 127 */ localFullValueDescription =
ValueUtility.translate(
_orb(),
ObjectStreamClass.lookup(this.vhandler.getAnyClassFromType(paramString)),
this.vhandler);
/* */ }
/* */ catch (Throwable localThrowable2) {
/* 130 */ if (this.orb == null) /* 131 */ this.orb = ORB.init();
/* 132 */ localFullValueDescription =
ValueUtility.translate(
this.orb,
ObjectStreamClass.lookup(this.vhandler.getAnyClassFromType(paramString)),
this.vhandler);
/* */ }
/* */
/* 136 */ if (localFullValueDescription != null)
/* 137 */ fvds.put(paramString, localFullValueDescription);
/* */ else {
/* 139 */ throw this.wrapper.missingLocalValueImpl(CompletionStatus.COMPLETED_MAYBE);
/* */ }
/* */ }
/* */
/* 143 */ return localFullValueDescription;
/* */ } catch (Throwable localThrowable1) {
/* 145 */ throw this.wrapper.incompatibleValueImpl(
CompletionStatus.COMPLETED_MAYBE, localThrowable1);
/* */ }
/* */ }
/* */
/* */ public FullValueDescription[] metas(String[] paramArrayOfString) {
/* 150 */ FullValueDescription[] arrayOfFullValueDescription =
new FullValueDescription[paramArrayOfString.length];
/* */
/* 152 */ for (int i = 0; i < paramArrayOfString.length; i++) {
/* 153 */ arrayOfFullValueDescription[i] = meta(paramArrayOfString[i]);
/* */ }
/* 155 */ return arrayOfFullValueDescription;
/* */ }
/* */
/* */ public String[] bases(String paramString) /* */ {
/* */ try
/* */ {
/* 163 */ if (this.vhandler == null) {
/* 164 */ this.vhandler = ValueHandlerImpl.getInstance(false);
/* */ }
/* */
/* 167 */ Stack localStack = new Stack();
/* 168 */ Class localClass =
ObjectStreamClass.lookup(this.vhandler.getClassFromType(paramString))
.forClass()
.getSuperclass();
/* */
/* 170 */ while (!localClass.equals(Object.class)) {
/* 171 */ localStack.push(this.vhandler.createForAnyType(localClass));
/* 172 */ localClass = localClass.getSuperclass();
/* */ }
/* */
/* 175 */ String[] arrayOfString = new String[localStack.size()];
/* 176 */ for (int i = arrayOfString.length - 1; i >= 0; i++) {
/* 177 */ arrayOfString[i] = ((String) localStack.pop());
/* */ }
/* 179 */ return arrayOfString;
/* */ } catch (Throwable localThrowable) {
/* 181 */ throw this.wrapper.missingLocalValueImpl(
CompletionStatus.COMPLETED_MAYBE, localThrowable);
/* */ }
/* */ }
/* */ }