| /* ObjectInputStream.java -- Class used to read serialized objects |
| Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005 |
| Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.io; |
| |
| import gnu.classpath.Configuration; |
| import gnu.java.io.ObjectIdentityWrapper; |
| |
| import java.lang.reflect.Array; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.lang.reflect.Proxy; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.Arrays; |
| import java.util.Hashtable; |
| import java.util.Vector; |
| |
| public class ObjectInputStream extends InputStream |
| implements ObjectInput, ObjectStreamConstants |
| { |
| /** |
| * Creates a new <code>ObjectInputStream</code> that will do all of |
| * its reading from <code>in</code>. This method also checks |
| * the stream by reading the header information (stream magic number |
| * and stream version). |
| * |
| * @exception IOException Reading stream header from underlying |
| * stream cannot be completed. |
| * |
| * @exception StreamCorruptedException An invalid stream magic |
| * number or stream version was read from the stream. |
| * |
| * @see #readStreamHeader() |
| */ |
| public ObjectInputStream(InputStream in) |
| throws IOException, StreamCorruptedException |
| { |
| if (Configuration.DEBUG) |
| { |
| String val = System.getProperty("gcj.dumpobjects"); |
| if (dump == false && val != null && !val.equals("")) |
| { |
| dump = true; |
| System.out.println ("Serialization debugging enabled"); |
| } |
| else if (dump == true && (val == null || val.equals(""))) |
| { |
| dump = false; |
| System.out.println ("Serialization debugging disabled"); |
| } |
| } |
| |
| this.resolveEnabled = false; |
| this.isDeserializing = false; |
| this.blockDataPosition = 0; |
| this.blockDataBytes = 0; |
| this.blockData = new byte[BUFFER_SIZE]; |
| this.blockDataInput = new DataInputStream(this); |
| this.realInputStream = new DataInputStream(in); |
| this.nextOID = baseWireHandle; |
| this.objectLookupTable = new Hashtable(); |
| this.validators = new Vector(); |
| this.classLookupTable = new Hashtable(); |
| setBlockDataMode(true); |
| readStreamHeader(); |
| } |
| |
| |
| /** |
| * Returns the next deserialized object read from the underlying stream. |
| * |
| * This method can be overriden by a class by implementing |
| * <code>private void readObject (ObjectInputStream)</code>. |
| * |
| * If an exception is thrown from this method, the stream is left in |
| * an undefined state. |
| * |
| * @exception ClassNotFoundException The class that an object being |
| * read in belongs to cannot be found. |
| * |
| * @exception IOException Exception from underlying |
| * <code>InputStream</code>. |
| */ |
| public final Object readObject() throws ClassNotFoundException, IOException |
| { |
| if (this.useSubclassMethod) |
| return readObjectOverride(); |
| |
| boolean was_deserializing; |
| |
| Object ret_val; |
| was_deserializing = this.isDeserializing; |
| |
| boolean is_consumed = false; |
| boolean old_mode = setBlockDataMode(false); |
| |
| this.isDeserializing = true; |
| |
| byte marker = this.realInputStream.readByte(); |
| |
| depth += 2; |
| |
| if(dump) dumpElement("MARKER: 0x" + Integer.toHexString(marker) + " "); |
| |
| try |
| { |
| switch (marker) |
| { |
| case TC_ENDBLOCKDATA: |
| { |
| ret_val = null; |
| is_consumed = true; |
| break; |
| } |
| |
| case TC_BLOCKDATA: |
| case TC_BLOCKDATALONG: |
| { |
| if (marker == TC_BLOCKDATALONG) |
| { if(dump) dumpElementln("BLOCKDATALONG"); } |
| else |
| { if(dump) dumpElementln("BLOCKDATA"); } |
| readNextBlock(marker); |
| throw new StreamCorruptedException("Unexpected blockData"); |
| } |
| |
| case TC_NULL: |
| { |
| if(dump) dumpElementln("NULL"); |
| ret_val = null; |
| break; |
| } |
| |
| case TC_REFERENCE: |
| { |
| if(dump) dumpElement("REFERENCE "); |
| Integer oid = new Integer(this.realInputStream.readInt()); |
| if(dump) dumpElementln(Integer.toHexString(oid.intValue())); |
| ret_val = ((ObjectIdentityWrapper) |
| this.objectLookupTable.get(oid)).object; |
| break; |
| } |
| |
| case TC_CLASS: |
| { |
| if(dump) dumpElementln("CLASS"); |
| ObjectStreamClass osc = (ObjectStreamClass)readObject(); |
| Class clazz = osc.forClass(); |
| assignNewHandle(clazz); |
| ret_val = clazz; |
| break; |
| } |
| |
| case TC_PROXYCLASSDESC: |
| { |
| if(dump) dumpElementln("PROXYCLASS"); |
| int n_intf = this.realInputStream.readInt(); |
| String[] intfs = new String[n_intf]; |
| for (int i = 0; i < n_intf; i++) |
| { |
| intfs[i] = this.realInputStream.readUTF(); |
| System.out.println(intfs[i]); |
| } |
| |
| boolean oldmode = setBlockDataMode(true); |
| Class cl = resolveProxyClass(intfs); |
| setBlockDataMode(oldmode); |
| |
| ObjectStreamClass osc = lookupClass(cl); |
| assignNewHandle(osc); |
| |
| if (!is_consumed) |
| { |
| byte b = this.realInputStream.readByte(); |
| if (b != TC_ENDBLOCKDATA) |
| throw new IOException("Data annotated to class was not consumed." + b); |
| } |
| else |
| is_consumed = false; |
| ObjectStreamClass superosc = (ObjectStreamClass)readObject(); |
| osc.setSuperclass(superosc); |
| ret_val = osc; |
| break; |
| } |
| |
| case TC_CLASSDESC: |
| { |
| ObjectStreamClass osc = readClassDescriptor(); |
| |
| if (!is_consumed) |
| { |
| byte b = this.realInputStream.readByte(); |
| if (b != TC_ENDBLOCKDATA) |
| throw new IOException("Data annotated to class was not consumed." + b); |
| } |
| else |
| is_consumed = false; |
| |
| osc.setSuperclass ((ObjectStreamClass)readObject()); |
| ret_val = osc; |
| break; |
| } |
| |
| case TC_STRING: |
| case TC_LONGSTRING: |
| { |
| if(dump) dumpElement("STRING="); |
| String s = this.realInputStream.readUTF(); |
| if(dump) dumpElementln(s); |
| ret_val = processResolution(null, s, assignNewHandle(s)); |
| break; |
| } |
| |
| case TC_ARRAY: |
| { |
| if(dump) dumpElementln("ARRAY"); |
| ObjectStreamClass osc = (ObjectStreamClass)readObject(); |
| Class componentType = osc.forClass().getComponentType(); |
| if(dump) dumpElement("ARRAY LENGTH="); |
| int length = this.realInputStream.readInt(); |
| if(dump) dumpElementln (length + "; COMPONENT TYPE=" + componentType); |
| Object array = Array.newInstance(componentType, length); |
| int handle = assignNewHandle(array); |
| readArrayElements(array, componentType); |
| if(dump) |
| for (int i = 0, len = Array.getLength(array); i < len; i++) |
| dumpElementln(" ELEMENT[" + i + "]=" + Array.get(array, i)); |
| ret_val = processResolution(null, array, handle); |
| break; |
| } |
| |
| case TC_OBJECT: |
| { |
| if(dump) dumpElementln("OBJECT"); |
| ObjectStreamClass osc = (ObjectStreamClass)readObject(); |
| Class clazz = osc.forClass(); |
| |
| if (!osc.realClassIsSerializable) |
| throw new NotSerializableException |
| (clazz + " is not Serializable, and thus cannot be deserialized."); |
| |
| if (osc.realClassIsExternalizable) |
| { |
| Externalizable obj = osc.newInstance(); |
| |
| int handle = assignNewHandle(obj); |
| |
| boolean read_from_blocks = ((osc.getFlags() & SC_BLOCK_DATA) != 0); |
| |
| boolean oldmode = this.readDataFromBlock; |
| if (read_from_blocks) |
| setBlockDataMode(true); |
| |
| obj.readExternal(this); |
| |
| if (read_from_blocks) |
| { |
| setBlockDataMode(oldmode); |
| if (!oldmode) |
| if (this.realInputStream.readByte() != TC_ENDBLOCKDATA) |
| throw new IOException("No end of block data seen for class with readExternal (ObjectInputStream) method."); |
| } |
| |
| ret_val = processResolution(osc, obj, handle); |
| break; |
| } // end if (osc.realClassIsExternalizable) |
| |
| Object obj = newObject(clazz, osc.firstNonSerializableParentConstructor); |
| |
| int handle = assignNewHandle(obj); |
| Object prevObject = this.currentObject; |
| ObjectStreamClass prevObjectStreamClass = this.currentObjectStreamClass; |
| |
| this.currentObject = obj; |
| ObjectStreamClass[] hierarchy = |
| inputGetObjectStreamClasses(clazz); |
| |
| for (int i = 0; i < hierarchy.length; i++) |
| { |
| this.currentObjectStreamClass = hierarchy[i]; |
| |
| if(dump) dumpElementln("Reading fields of " + this.currentObjectStreamClass.getName ()); |
| |
| // XXX: should initialize fields in classes in the hierarchy |
| // that aren't in the stream |
| // should skip over classes in the stream that aren't in the |
| // real classes hierarchy |
| |
| Method readObjectMethod = this.currentObjectStreamClass.readObjectMethod; |
| if (readObjectMethod != null) |
| { |
| fieldsAlreadyRead = false; |
| boolean oldmode = setBlockDataMode(true); |
| callReadMethod(readObjectMethod, this.currentObjectStreamClass.forClass(), obj); |
| setBlockDataMode(oldmode); |
| } |
| else |
| { |
| readFields(obj, currentObjectStreamClass); |
| } |
| |
| if (this.currentObjectStreamClass.hasWriteMethod()) |
| { |
| if(dump) dumpElement("ENDBLOCKDATA? "); |
| try |
| { |
| // FIXME: XXX: This try block is to |
| // catch EOF which is thrown for some |
| // objects. That indicates a bug in |
| // the logic. |
| |
| if (this.realInputStream.readByte() != TC_ENDBLOCKDATA) |
| throw new IOException |
| ("No end of block data seen for class with readObject (ObjectInputStream) method."); |
| if(dump) dumpElementln("yes"); |
| } |
| // catch (EOFException e) |
| // { |
| // if(dump) dumpElementln("no, got EOFException"); |
| // } |
| catch (IOException e) |
| { |
| if(dump) dumpElementln("no, got IOException"); |
| } |
| } |
| } |
| |
| this.currentObject = prevObject; |
| this.currentObjectStreamClass = prevObjectStreamClass; |
| ret_val = processResolution(osc, obj, handle); |
| |
| break; |
| } |
| |
| case TC_RESET: |
| if(dump) dumpElementln("RESET"); |
| clearHandles(); |
| ret_val = readObject(); |
| break; |
| |
| case TC_EXCEPTION: |
| { |
| if(dump) dumpElement("EXCEPTION="); |
| Exception e = (Exception)readObject(); |
| if(dump) dumpElementln(e.toString()); |
| clearHandles(); |
| throw new WriteAbortedException("Exception thrown during writing of stream", e); |
| } |
| |
| default: |
| throw new IOException("Unknown marker on stream: " + marker); |
| } |
| } |
| finally |
| { |
| setBlockDataMode(old_mode); |
| |
| this.isDeserializing = was_deserializing; |
| |
| depth -= 2; |
| |
| if (! was_deserializing) |
| { |
| if (validators.size() > 0) |
| invokeValidators(); |
| } |
| } |
| |
| return ret_val; |
| } |
| |
| /** |
| * This method makes a partial check of types for the fields |
| * contained given in arguments. It checks primitive types of |
| * fields1 against non primitive types of fields2. This method |
| * assumes the two lists has already been sorted according to |
| * the Java specification. |
| * |
| * @param name Name of the class owning the given fields. |
| * @param fields1 First list to check. |
| * @param fields2 Second list to check. |
| * @throws InvalidClassException if a field in fields1, which has a primitive type, is a present |
| * in the non primitive part in fields2. |
| */ |
| private void checkTypeConsistency(String name, ObjectStreamField[] fields1, ObjectStreamField[] fields2) |
| throws InvalidClassException |
| { |
| int nonPrimitive = 0; |
| |
| for (nonPrimitive = 0; |
| nonPrimitive < fields1.length |
| && fields1[nonPrimitive].isPrimitive(); nonPrimitive++) |
| { |
| } |
| |
| if (nonPrimitive == fields1.length) |
| return; |
| |
| int i = 0; |
| ObjectStreamField f1; |
| ObjectStreamField f2; |
| |
| while (i < fields2.length |
| && nonPrimitive < fields1.length) |
| { |
| f1 = fields1[nonPrimitive]; |
| f2 = fields2[i]; |
| |
| if (!f2.isPrimitive()) |
| break; |
| |
| int compVal = f1.getName().compareTo (f2.getName()); |
| |
| if (compVal < 0) |
| { |
| nonPrimitive++; |
| } |
| else if (compVal > 0) |
| { |
| i++; |
| } |
| else |
| { |
| throw new InvalidClassException |
| ("invalid field type for " + f2.getName() + |
| " in class " + name); |
| } |
| } |
| } |
| |
| /** |
| * This method reads a class descriptor from the real input stream |
| * and use these data to create a new instance of ObjectStreamClass. |
| * Fields are sorted and ordered for the real read which occurs for |
| * each instance of the described class. Be aware that if you call that |
| * method you must ensure that the stream is synchronized, in the other |
| * case it may be completely desynchronized. |
| * |
| * @return A new instance of ObjectStreamClass containing the freshly |
| * created descriptor. |
| * @throws ClassNotFoundException if the required class to build the |
| * descriptor has not been found in the system. |
| * @throws IOException An input/output error occured. |
| * @throws InvalidClassException If there was a compatibility problem |
| * between the class present in the system and the serialized class. |
| */ |
| protected ObjectStreamClass readClassDescriptor() |
| throws ClassNotFoundException, IOException |
| { |
| if(dump) dumpElement("CLASSDESC NAME="); |
| String name = this.realInputStream.readUTF(); |
| if(dump) dumpElement(name + "; UID="); |
| long uid = this.realInputStream.readLong (); |
| if(dump) dumpElement(Long.toHexString(uid) + "; FLAGS="); |
| byte flags = this.realInputStream.readByte (); |
| if(dump) dumpElement(Integer.toHexString(flags) + "; FIELD COUNT="); |
| short field_count = this.realInputStream.readShort(); |
| if(dump) dumpElementln(Short.toString(field_count)); |
| ObjectStreamField[] fields = new ObjectStreamField[field_count]; |
| ObjectStreamClass osc = new ObjectStreamClass(name, uid, |
| flags, fields); |
| assignNewHandle(osc); |
| |
| if (callersClassLoader == null) |
| callersClassLoader = currentLoader(); |
| |
| for (int i = 0; i < field_count; i++) |
| { |
| if(dump) dumpElement(" TYPE CODE="); |
| char type_code = (char)this.realInputStream.readByte(); |
| if(dump) dumpElement(type_code + "; FIELD NAME="); |
| String field_name = this.realInputStream.readUTF(); |
| if(dump) dumpElementln(field_name); |
| String class_name; |
| |
| // If the type code is an array or an object we must |
| // decode a String here. In the other case we convert |
| // the type code and pass it to ObjectStreamField. |
| // Type codes are decoded by gnu.java.lang.reflect.TypeSignature. |
| if (type_code == 'L' || type_code == '[') |
| class_name = (String)readObject(); |
| else |
| class_name = String.valueOf(type_code); |
| |
| fields[i] = |
| new ObjectStreamField(field_name, class_name, callersClassLoader); |
| } |
| |
| /* Now that fields have been read we may resolve the class |
| * (and read annotation if needed). */ |
| Class clazz; |
| try |
| { |
| clazz = resolveClass(osc); |
| } |
| catch (ClassNotFoundException cnfe) |
| { |
| // Maybe it was an primitive class? |
| if (name.equals("void")) |
| clazz = Void.TYPE; |
| else if (name.equals("boolean")) |
| clazz = Boolean.TYPE; |
| else if (name.equals("byte")) |
| clazz = Byte.TYPE; |
| else if (name.equals("short")) |
| clazz = Short.TYPE; |
| else if (name.equals("char")) |
| clazz = Character.TYPE; |
| else if (name.equals("int")) |
| clazz = Integer.TYPE; |
| else if (name.equals("long")) |
| clazz = Long.TYPE; |
| else if (name.equals("float")) |
| clazz = Float.TYPE; |
| else if (name.equals("double")) |
| clazz = Double.TYPE; |
| else |
| throw cnfe; |
| } |
| |
| boolean oldmode = setBlockDataMode(true); |
| osc.setClass(clazz, lookupClass(clazz.getSuperclass())); |
| classLookupTable.put(clazz, osc); |
| setBlockDataMode(oldmode); |
| |
| // find the first non-serializable, non-abstract |
| // class in clazz's inheritance hierarchy |
| Class first_nonserial = clazz.getSuperclass(); |
| // Maybe it is a primitive class, those don't have a super class, |
| // or Object itself. Otherwise we can keep getting the superclass |
| // till we hit the Object class, or some other non-serializable class. |
| |
| if (first_nonserial == null) |
| first_nonserial = clazz; |
| else |
| while (Serializable.class.isAssignableFrom(first_nonserial) |
| || Modifier.isAbstract(first_nonserial.getModifiers())) |
| first_nonserial = first_nonserial.getSuperclass(); |
| |
| final Class local_constructor_class = first_nonserial; |
| |
| osc.firstNonSerializableParentConstructor = |
| (Constructor)AccessController.doPrivileged(new PrivilegedAction() |
| { |
| public Object run() |
| { |
| try |
| { |
| Constructor c = local_constructor_class. |
| getDeclaredConstructor(new Class[0]); |
| if (Modifier.isPrivate(c.getModifiers())) |
| return null; |
| return c; |
| } |
| catch (NoSuchMethodException e) |
| { |
| // error will be reported later, in newObject() |
| return null; |
| } |
| } |
| }); |
| |
| osc.realClassIsSerializable = Serializable.class.isAssignableFrom(clazz); |
| osc.realClassIsExternalizable = Externalizable.class.isAssignableFrom(clazz); |
| |
| ObjectStreamField[] stream_fields = osc.fields; |
| ObjectStreamField[] real_fields = ObjectStreamClass.lookupForClassObject(clazz).fields; |
| ObjectStreamField[] fieldmapping = new ObjectStreamField[2 * Math.max(stream_fields.length, real_fields.length)]; |
| |
| int stream_idx = 0; |
| int real_idx = 0; |
| int map_idx = 0; |
| |
| /* |
| * Check that there is no type inconsistencies between the lists. |
| * A special checking must be done for the two groups: primitive types and |
| * not primitive types. |
| */ |
| checkTypeConsistency(name, real_fields, stream_fields); |
| checkTypeConsistency(name, stream_fields, real_fields); |
| |
| |
| while (stream_idx < stream_fields.length |
| || real_idx < real_fields.length) |
| { |
| ObjectStreamField stream_field = null; |
| ObjectStreamField real_field = null; |
| |
| if (stream_idx == stream_fields.length) |
| { |
| real_field = real_fields[real_idx++]; |
| } |
| else if (real_idx == real_fields.length) |
| { |
| stream_field = stream_fields[stream_idx++]; |
| } |
| else |
| { |
| int comp_val = |
| real_fields[real_idx].compareTo (stream_fields[stream_idx]); |
| |
| if (comp_val < 0) |
| { |
| real_field = real_fields[real_idx++]; |
| } |
| else if (comp_val > 0) |
| { |
| stream_field = stream_fields[stream_idx++]; |
| } |
| else |
| { |
| stream_field = stream_fields[stream_idx++]; |
| real_field = real_fields[real_idx++]; |
| if (stream_field.getType() != real_field.getType()) |
| throw new InvalidClassException |
| ("invalid field type for " + real_field.getName() + |
| " in class " + name); |
| } |
| } |
| |
| /* If some of stream_fields does not correspond to any of real_fields, |
| * or the opposite, then fieldmapping will go short. |
| */ |
| if (map_idx == fieldmapping.length) |
| { |
| ObjectStreamField[] newfieldmapping = |
| new ObjectStreamField[fieldmapping.length + 2]; |
| System.arraycopy(fieldmapping, 0, |
| newfieldmapping, 0, fieldmapping.length); |
| fieldmapping = newfieldmapping; |
| } |
| fieldmapping[map_idx++] = stream_field; |
| fieldmapping[map_idx++] = real_field; |
| } |
| osc.fieldMapping = fieldmapping; |
| |
| return osc; |
| } |
| |
| /** |
| * Reads the current objects non-transient, non-static fields from |
| * the current class from the underlying output stream. |
| * |
| * This method is intended to be called from within a object's |
| * <code>private void readObject (ObjectInputStream)</code> |
| * method. |
| * |
| * @exception ClassNotFoundException The class that an object being |
| * read in belongs to cannot be found. |
| * |
| * @exception NotActiveException This method was called from a |
| * context other than from the current object's and current class's |
| * <code>private void readObject (ObjectInputStream)</code> |
| * method. |
| * |
| * @exception IOException Exception from underlying |
| * <code>OutputStream</code>. |
| */ |
| public void defaultReadObject() |
| throws ClassNotFoundException, IOException, NotActiveException |
| { |
| if (this.currentObject == null || this.currentObjectStreamClass == null) |
| throw new NotActiveException("defaultReadObject called by non-active" |
| + " class and/or object"); |
| |
| if (fieldsAlreadyRead) |
| throw new NotActiveException("defaultReadObject called but fields " |
| + "already read from stream (by " |
| + "defaultReadObject or readFields)"); |
| |
| boolean oldmode = setBlockDataMode(false); |
| readFields(this.currentObject, this.currentObjectStreamClass); |
| setBlockDataMode(oldmode); |
| |
| fieldsAlreadyRead = true; |
| } |
| |
| |
| /** |
| * Registers a <code>ObjectInputValidation</code> to be carried out |
| * on the object graph currently being deserialized before it is |
| * returned to the original caller of <code>readObject ()</code>. |
| * The order of validation for multiple |
| * <code>ObjectInputValidation</code>s can be controled using |
| * <code>priority</code>. Validators with higher priorities are |
| * called first. |
| * |
| * @see java.io.ObjectInputValidation |
| * |
| * @exception InvalidObjectException <code>validator</code> is |
| * <code>null</code> |
| * |
| * @exception NotActiveException an attempt was made to add a |
| * validator outside of the <code>readObject</code> method of the |
| * object currently being deserialized |
| */ |
| public void registerValidation(ObjectInputValidation validator, |
| int priority) |
| throws InvalidObjectException, NotActiveException |
| { |
| if (this.currentObject == null || this.currentObjectStreamClass == null) |
| throw new NotActiveException("registerValidation called by non-active " |
| + "class and/or object"); |
| |
| if (validator == null) |
| throw new InvalidObjectException("attempt to add a null " |
| + "ObjectInputValidation object"); |
| |
| this.validators.addElement(new ValidatorAndPriority (validator, |
| priority)); |
| } |
| |
| |
| /** |
| * Called when a class is being deserialized. This is a hook to |
| * allow subclasses to read in information written by the |
| * <code>annotateClass (Class)</code> method of an |
| * <code>ObjectOutputStream</code>. |
| * |
| * This implementation looks up the active call stack for a |
| * <code>ClassLoader</code>; if a <code>ClassLoader</code> is found, |
| * it is used to load the class associated with <code>osc</code>, |
| * otherwise, the default system <code>ClassLoader</code> is used. |
| * |
| * @exception IOException Exception from underlying |
| * <code>OutputStream</code>. |
| * |
| * @see java.io.ObjectOutputStream#annotateClass (java.lang.Class) |
| */ |
| protected Class resolveClass(ObjectStreamClass osc) |
| throws ClassNotFoundException, IOException |
| { |
| if (callersClassLoader == null) |
| { |
| callersClassLoader = currentLoader (); |
| if (Configuration.DEBUG && dump) |
| { |
| dumpElementln ("CallersClassLoader = " + callersClassLoader); |
| } |
| } |
| |
| return Class.forName(osc.getName(), true, callersClassLoader); |
| } |
| |
| /** |
| * This method invokes the method currentClassLoader for the |
| * current security manager (or build an empty one if it is not |
| * present). |
| * |
| * @return The most recent non-system ClassLoader on the execution stack. |
| * @see java.lang.SecurityManager#currentClassLoader() |
| */ |
| private ClassLoader currentLoader() |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm == null) |
| sm = new SecurityManager () {}; |
| |
| return currentClassLoader(sm); |
| } |
| |
| /** |
| * Lookup a class stored in the local hashtable. If it is not |
| * use the global lookup function in ObjectStreamClass to build |
| * the ObjectStreamClass. This method is requested according to |
| * the behaviour detected in the JDK by Kaffe's team. |
| * |
| * @param clazz Class to lookup in the hash table or for which |
| * we must build a descriptor. |
| * @return A valid instance of ObjectStreamClass corresponding |
| * to the specified class. |
| */ |
| private ObjectStreamClass lookupClass(Class clazz) |
| { |
| if (clazz == null) |
| return null; |
| |
| ObjectStreamClass oclazz; |
| oclazz = (ObjectStreamClass)classLookupTable.get(clazz); |
| if (oclazz == null) |
| return ObjectStreamClass.lookup(clazz); |
| else |
| return oclazz; |
| } |
| |
| /** |
| * Reconstruct class hierarchy the same way |
| * {@link java.io.ObjectStreamClass.getObjectStreamClasses(java.lang.Class)} does |
| * but using lookupClass instead of ObjectStreamClass.lookup. This |
| * dup is necessary localize the lookup table. Hopefully some future |
| * rewritings will be able to prevent this. |
| * |
| * @param clazz This is the class for which we want the hierarchy. |
| * |
| * @return An array of valid {@link java.io.ObjectStreamClass} instances which |
| * represent the class hierarchy for clazz. |
| */ |
| private ObjectStreamClass[] inputGetObjectStreamClasses(Class clazz) |
| { |
| ObjectStreamClass osc = lookupClass(clazz); |
| |
| if (osc == null) |
| return new ObjectStreamClass[0]; |
| else |
| { |
| Vector oscs = new Vector(); |
| |
| while (osc != null) |
| { |
| oscs.addElement(osc); |
| osc = osc.getSuper(); |
| } |
| |
| int count = oscs.size(); |
| ObjectStreamClass[] sorted_oscs = new ObjectStreamClass[count]; |
| |
| for (int i = count - 1; i >= 0; i--) |
| sorted_oscs[count - i - 1] = (ObjectStreamClass) oscs.elementAt(i); |
| |
| return sorted_oscs; |
| } |
| } |
| |
| /** |
| * Allows subclasses to resolve objects that are read from the |
| * stream with other objects to be returned in their place. This |
| * method is called the first time each object is encountered. |
| * |
| * This method must be enabled before it will be called in the |
| * serialization process. |
| * |
| * @exception IOException Exception from underlying |
| * <code>OutputStream</code>. |
| * |
| * @see #enableResolveObject(boolean) |
| */ |
| protected Object resolveObject(Object obj) throws IOException |
| { |
| return obj; |
| } |
| |
| |
| protected Class resolveProxyClass(String[] intfs) |
| throws IOException, ClassNotFoundException |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| |
| if (sm == null) |
| sm = new SecurityManager() {}; |
| |
| ClassLoader cl = currentClassLoader(sm); |
| |
| Class[] clss = new Class[intfs.length]; |
| if(cl == null) |
| { |
| for (int i = 0; i < intfs.length; i++) |
| clss[i] = Class.forName(intfs[i]); |
| cl = ClassLoader.getSystemClassLoader(); |
| } |
| else |
| for (int i = 0; i < intfs.length; i++) |
| clss[i] = cl.loadClass(intfs[i]); |
| try |
| { |
| return Proxy.getProxyClass(cl, clss); |
| } |
| catch (IllegalArgumentException e) |
| { |
| throw new ClassNotFoundException(null, e); |
| } |
| } |
| |
| /** |
| * If <code>enable</code> is <code>true</code> and this object is |
| * trusted, then <code>resolveObject (Object)</code> will be called |
| * in subsequent calls to <code>readObject (Object)</code>. |
| * Otherwise, <code>resolveObject (Object)</code> will not be called. |
| * |
| * @exception SecurityException This class is not trusted. |
| */ |
| protected boolean enableResolveObject (boolean enable) |
| throws SecurityException |
| { |
| if (enable) |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| sm.checkPermission(new SerializablePermission("enableSubstitution")); |
| } |
| |
| boolean old_val = this.resolveEnabled; |
| this.resolveEnabled = enable; |
| return old_val; |
| } |
| |
| /** |
| * Reads stream magic and stream version information from the |
| * underlying stream. |
| * |
| * @exception IOException Exception from underlying stream. |
| * |
| * @exception StreamCorruptedException An invalid stream magic |
| * number or stream version was read from the stream. |
| */ |
| protected void readStreamHeader() |
| throws IOException, StreamCorruptedException |
| { |
| if(dump) dumpElement("STREAM MAGIC "); |
| if (this.realInputStream.readShort() != STREAM_MAGIC) |
| throw new StreamCorruptedException("Invalid stream magic number"); |
| |
| if(dump) dumpElementln("STREAM VERSION "); |
| if (this.realInputStream.readShort() != STREAM_VERSION) |
| throw new StreamCorruptedException("Invalid stream version number"); |
| } |
| |
| public int read() throws IOException |
| { |
| if (this.readDataFromBlock) |
| { |
| if (this.blockDataPosition >= this.blockDataBytes) |
| readNextBlock(); |
| return (this.blockData[this.blockDataPosition++] & 0xff); |
| } |
| else |
| return this.realInputStream.read(); |
| } |
| |
| public int read(byte[] data, int offset, int length) throws IOException |
| { |
| if (this.readDataFromBlock) |
| { |
| if (this.blockDataPosition + length > this.blockDataBytes) |
| { |
| int remain = this.blockDataBytes - this.blockDataPosition; |
| if (remain != 0) |
| { |
| System.arraycopy(this.blockData, this.blockDataPosition, |
| data, offset, remain); |
| offset += remain; |
| length -= remain; |
| } |
| readNextBlock (); |
| } |
| |
| System.arraycopy(this.blockData, this.blockDataPosition, |
| data, offset, length); |
| this.blockDataPosition += length; |
| |
| return length; |
| } |
| else |
| return this.realInputStream.read(data, offset, length); |
| } |
| |
| public int available() throws IOException |
| { |
| if (this.readDataFromBlock) |
| { |
| if (this.blockDataPosition >= this.blockDataBytes) |
| readNextBlock (); |
| |
| return this.blockDataBytes - this.blockDataPosition; |
| } |
| else |
| return this.realInputStream.available(); |
| } |
| |
| public void close() throws IOException |
| { |
| this.realInputStream.close(); |
| } |
| |
| public boolean readBoolean() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode (true); |
| boolean value = this.dataInputStream.readBoolean (); |
| if (switchmode) |
| setBlockDataMode (oldmode); |
| return value; |
| } |
| |
| public byte readByte() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| byte value = this.dataInputStream.readByte(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public int readUnsignedByte() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| int value = this.dataInputStream.readUnsignedByte(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public short readShort() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| short value = this.dataInputStream.readShort(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public int readUnsignedShort() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| int value = this.dataInputStream.readUnsignedShort(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public char readChar() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| char value = this.dataInputStream.readChar(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public int readInt() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 4) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| int value = this.dataInputStream.readInt(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public long readLong() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 8) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| long value = this.dataInputStream.readLong(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public float readFloat() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 4) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| float value = this.dataInputStream.readFloat(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public double readDouble() throws IOException |
| { |
| boolean switchmode = true; |
| boolean oldmode = this.readDataFromBlock; |
| if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 8) |
| switchmode = false; |
| if (switchmode) |
| oldmode = setBlockDataMode(true); |
| double value = this.dataInputStream.readDouble(); |
| if (switchmode) |
| setBlockDataMode(oldmode); |
| return value; |
| } |
| |
| public void readFully(byte data[]) throws IOException |
| { |
| this.dataInputStream.readFully(data); |
| } |
| |
| public void readFully(byte data[], int offset, int size) |
| throws IOException |
| { |
| this.dataInputStream.readFully(data, offset, size); |
| } |
| |
| public int skipBytes(int len) throws IOException |
| { |
| return this.dataInputStream.skipBytes(len); |
| } |
| |
| /** |
| * @deprecated |
| * @see java.io.DataInputStream#readLine () |
| */ |
| public String readLine() throws IOException |
| { |
| return this.dataInputStream.readLine(); |
| } |
| |
| public String readUTF() throws IOException |
| { |
| return this.dataInputStream.readUTF(); |
| } |
| |
| /** |
| * This class allows a class to specify exactly which fields should |
| * be read, and what values should be read for these fields. |
| * |
| * XXX: finish up comments |
| */ |
| public abstract static class GetField |
| { |
| public abstract ObjectStreamClass getObjectStreamClass(); |
| |
| public abstract boolean defaulted(String name) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract boolean get(String name, boolean defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract char get(String name, char defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract byte get(String name, byte defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract short get(String name, short defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract int get(String name, int defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract long get(String name, long defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract float get(String name, float defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract double get(String name, double defvalue) |
| throws IOException, IllegalArgumentException; |
| |
| public abstract Object get(String name, Object defvalue) |
| throws IOException, IllegalArgumentException; |
| } |
| |
| /** |
| * This method should be called by a method called 'readObject' in the |
| * deserializing class (if present). It cannot (and should not)be called |
| * outside of it. Its goal is to read all fields in the real input stream |
| * and keep them accessible through the {@link #GetField} class. Calling |
| * this method will not alter the deserializing object. |
| * |
| * @return A valid freshly created 'GetField' instance to get access to |
| * the deserialized stream. |
| * @throws IOException An input/output exception occured. |
| * @throws ClassNotFoundException |
| * @throws NotActiveException |
| */ |
| public GetField readFields() |
| throws IOException, ClassNotFoundException, NotActiveException |
| { |
| if (this.currentObject == null || this.currentObjectStreamClass == null) |
| throw new NotActiveException("readFields called by non-active class and/or object"); |
| |
| if (prereadFields != null) |
| return prereadFields; |
| |
| if (fieldsAlreadyRead) |
| throw new NotActiveException("readFields called but fields already read from" |
| + " stream (by defaultReadObject or readFields)"); |
| |
| final ObjectStreamClass clazz = this.currentObjectStreamClass; |
| final byte[] prim_field_data = new byte[clazz.primFieldSize]; |
| final Object[] objs = new Object[clazz.objectFieldCount]; |
| |
| // Apparently Block data is not used with GetField as per |
| // empirical evidence against JDK 1.2. Also see Mauve test |
| // java.io.ObjectInputOutput.Test.GetPutField. |
| boolean oldmode = setBlockDataMode(false); |
| readFully(prim_field_data); |
| for (int i = 0; i < objs.length; ++ i) |
| objs[i] = readObject(); |
| setBlockDataMode(oldmode); |
| |
| prereadFields = new GetField() |
| { |
| public ObjectStreamClass getObjectStreamClass() |
| { |
| return clazz; |
| } |
| |
| public boolean defaulted(String name) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField f = clazz.getField(name); |
| |
| /* First if we have a serialized field use the descriptor */ |
| if (f != null) |
| { |
| /* It is in serialPersistentFields but setClass tells us |
| * it should not be set. This value is defaulted. |
| */ |
| if (f.isPersistent() && !f.isToSet()) |
| return true; |
| |
| return false; |
| } |
| |
| /* This is not a serialized field. There should be |
| * a default value only if the field really exists. |
| */ |
| try |
| { |
| return (clazz.forClass().getDeclaredField (name) != null); |
| } |
| catch (NoSuchFieldException e) |
| { |
| throw new IllegalArgumentException(e.getMessage()); |
| } |
| } |
| |
| public boolean get(String name, boolean defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Boolean.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| return prim_field_data[field.getOffset()] == 0 ? false : true; |
| } |
| |
| public char get(String name, char defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Character.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| int off = field.getOffset(); |
| |
| return (char)(((prim_field_data[off++] & 0xFF) << 8) |
| | (prim_field_data[off] & 0xFF)); |
| } |
| |
| public byte get(String name, byte defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Byte.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| return prim_field_data[field.getOffset()]; |
| } |
| |
| public short get(String name, short defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Short.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| int off = field.getOffset(); |
| |
| return (short)(((prim_field_data[off++] & 0xFF) << 8) |
| | (prim_field_data[off] & 0xFF)); |
| } |
| |
| public int get(String name, int defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Integer.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| int off = field.getOffset(); |
| |
| return ((prim_field_data[off++] & 0xFF) << 24) |
| | ((prim_field_data[off++] & 0xFF) << 16) |
| | ((prim_field_data[off++] & 0xFF) << 8) |
| | (prim_field_data[off] & 0xFF); |
| } |
| |
| public long get(String name, long defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Long.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| int off = field.getOffset(); |
| |
| return (long)(((prim_field_data[off++] & 0xFFL) << 56) |
| | ((prim_field_data[off++] & 0xFFL) << 48) |
| | ((prim_field_data[off++] & 0xFFL) << 40) |
| | ((prim_field_data[off++] & 0xFFL) << 32) |
| | ((prim_field_data[off++] & 0xFF) << 24) |
| | ((prim_field_data[off++] & 0xFF) << 16) |
| | ((prim_field_data[off++] & 0xFF) << 8) |
| | (prim_field_data[off] & 0xFF)); |
| } |
| |
| public float get(String name, float defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Float.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| int off = field.getOffset(); |
| |
| return Float.intBitsToFloat(((prim_field_data[off++] & 0xFF) << 24) |
| | ((prim_field_data[off++] & 0xFF) << 16) |
| | ((prim_field_data[off++] & 0xFF) << 8) |
| | (prim_field_data[off] & 0xFF)); |
| } |
| |
| public double get(String name, double defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = getField(name, Double.TYPE); |
| |
| if (field == null) |
| return defvalue; |
| |
| int off = field.getOffset(); |
| |
| return Double.longBitsToDouble |
| ( (long) (((prim_field_data[off++] & 0xFFL) << 56) |
| | ((prim_field_data[off++] & 0xFFL) << 48) |
| | ((prim_field_data[off++] & 0xFFL) << 40) |
| | ((prim_field_data[off++] & 0xFFL) << 32) |
| | ((prim_field_data[off++] & 0xFF) << 24) |
| | ((prim_field_data[off++] & 0xFF) << 16) |
| | ((prim_field_data[off++] & 0xFF) << 8) |
| | (prim_field_data[off] & 0xFF))); |
| } |
| |
| public Object get(String name, Object defvalue) |
| throws IOException, IllegalArgumentException |
| { |
| ObjectStreamField field = |
| getField(name, defvalue == null ? null : defvalue.getClass ()); |
| |
| if (field == null) |
| return defvalue; |
| |
| return objs[field.getOffset()]; |
| } |
| |
| private ObjectStreamField getField(String name, Class type) |
| throws IllegalArgumentException |
| { |
| ObjectStreamField field = clazz.getField(name); |
| boolean illegal = false; |
| |
| try |
| { |
| try |
| { |
| Class field_type = field.getType(); |
| |
| if (type == field_type || |
| (type == null && !field_type.isPrimitive())) |
| { |
| /* See defaulted */ |
| return field; |
| } |
| |
| illegal = true; |
| throw new IllegalArgumentException |
| ("Field requested is of type " |
| + field_type.getName() |
| + ", but requested type was " |
| + (type == null ? "Object" : type.getName())); |
| } |
| catch (NullPointerException _) |
| { |
| /* Here we catch NullPointerException, because it may |
| only come from the call 'field.getType()'. If field |
| is null, we have to return null and classpath ethic |
| say we must try to avoid 'if (xxx == null)'. |
| */ |
| } |
| catch (IllegalArgumentException e) |
| { |
| throw e; |
| } |
| |
| return null; |
| } |
| finally |
| { |
| /* If this is an unassigned field we should return |
| * the default value. |
| */ |
| if (!illegal && field != null && !field.isToSet() && field.isPersistent()) |
| return null; |
| |
| /* We do not want to modify transient fields. They should |
| * be left to 0. |
| */ |
| try |
| { |
| Field f = clazz.forClass().getDeclaredField(name); |
| if (Modifier.isTransient(f.getModifiers())) |
| throw new IllegalArgumentException |
| ("no such field (non transient) " + name); |
| if (field == null && f.getType() != type) |
| throw new IllegalArgumentException |
| ("Invalid requested type for field " + name); |
| } |
| catch (NoSuchFieldException e) |
| { |
| if (field == null) |
| throw new IllegalArgumentException(e.getMessage()); |
| } |
| |
| } |
| } |
| }; |
| |
| fieldsAlreadyRead = true; |
| return prereadFields; |
| } |
| |
| /** |
| * Protected constructor that allows subclasses to override |
| * deserialization. This constructor should be called by subclasses |
| * that wish to override <code>readObject (Object)</code>. This |
| * method does a security check <i>NOTE: currently not |
| * implemented</i>, then sets a flag that informs |
| * <code>readObject (Object)</code> to call the subclasses |
| * <code>readObjectOverride (Object)</code> method. |
| * |
| * @see #readObjectOverride() |
| */ |
| protected ObjectInputStream() |
| throws IOException, SecurityException |
| { |
| SecurityManager sec_man = System.getSecurityManager(); |
| if (sec_man != null) |
| sec_man.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION); |
| this.useSubclassMethod = true; |
| } |
| |
| /** |
| * This method allows subclasses to override the default |
| * de serialization mechanism provided by |
| * <code>ObjectInputStream</code>. To make this method be used for |
| * writing objects, subclasses must invoke the 0-argument |
| * constructor on this class from their constructor. |
| * |
| * @see #ObjectInputStream() |
| */ |
| protected Object readObjectOverride() |
| throws ClassNotFoundException, IOException, OptionalDataException |
| { |
| throw new IOException("Subclass of ObjectInputStream must implement readObjectOverride"); |
| } |
| |
| /** |
| * Assigns the next available handle to <code>obj</code>. |
| * |
| * @param obj The object for which we want a new handle. |
| * @return A valid handle for the specified object. |
| */ |
| private int assignNewHandle(Object obj) |
| { |
| this.objectLookupTable.put(new Integer(this.nextOID), |
| new ObjectIdentityWrapper(obj)); |
| return this.nextOID++; |
| } |
| |
| private Object processResolution(ObjectStreamClass osc, Object obj, int handle) |
| throws IOException |
| { |
| if (osc != null && obj instanceof Serializable) |
| { |
| try |
| { |
| Method m = osc.readResolveMethod; |
| if(m != null) |
| { |
| obj = m.invoke(obj, new Object[] {}); |
| } |
| } |
| catch (IllegalAccessException ignore) |
| { |
| } |
| catch (InvocationTargetException ignore) |
| { |
| } |
| } |
| |
| if (this.resolveEnabled) |
| obj = resolveObject(obj); |
| |
| this.objectLookupTable.put(new Integer(handle), |
| new ObjectIdentityWrapper(obj)); |
| |
| return obj; |
| } |
| |
| private void clearHandles() |
| { |
| this.objectLookupTable.clear(); |
| this.nextOID = baseWireHandle; |
| } |
| |
| private void readNextBlock() throws IOException |
| { |
| readNextBlock(this.realInputStream.readByte()); |
| } |
| |
| private void readNextBlock(byte marker) throws IOException |
| { |
| if (marker == TC_BLOCKDATA) |
| { |
| if(dump) dumpElement("BLOCK DATA SIZE="); |
| this.blockDataBytes = this.realInputStream.readUnsignedByte(); |
| if(dump) dumpElementln (Integer.toString(this.blockDataBytes)); |
| } |
| else if (marker == TC_BLOCKDATALONG) |
| { |
| if(dump) dumpElement("BLOCK DATA LONG SIZE="); |
| this.blockDataBytes = this.realInputStream.readInt(); |
| if(dump) dumpElementln (Integer.toString(this.blockDataBytes)); |
| } |
| else |
| { |
| throw new EOFException("Attempt to read primitive data, but no data block is active."); |
| } |
| |
| if (this.blockData.length < this.blockDataBytes) |
| this.blockData = new byte[this.blockDataBytes]; |
| |
| this.realInputStream.readFully (this.blockData, 0, this.blockDataBytes); |
| this.blockDataPosition = 0; |
| } |
| |
| private void readArrayElements (Object array, Class clazz) |
| throws ClassNotFoundException, IOException |
| { |
| if (clazz.isPrimitive()) |
| { |
| if (clazz == Boolean.TYPE) |
| { |
| boolean[] cast_array = (boolean[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readBoolean(); |
| return; |
| } |
| if (clazz == Byte.TYPE) |
| { |
| byte[] cast_array = (byte[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readByte(); |
| return; |
| } |
| if (clazz == Character.TYPE) |
| { |
| char[] cast_array = (char[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readChar(); |
| return; |
| } |
| if (clazz == Double.TYPE) |
| { |
| double[] cast_array = (double[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readDouble(); |
| return; |
| } |
| if (clazz == Float.TYPE) |
| { |
| float[] cast_array = (float[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readFloat(); |
| return; |
| } |
| if (clazz == Integer.TYPE) |
| { |
| int[] cast_array = (int[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readInt(); |
| return; |
| } |
| if (clazz == Long.TYPE) |
| { |
| long[] cast_array = (long[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readLong(); |
| return; |
| } |
| if (clazz == Short.TYPE) |
| { |
| short[] cast_array = (short[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = this.realInputStream.readShort(); |
| return; |
| } |
| } |
| else |
| { |
| Object[] cast_array = (Object[])array; |
| for (int i=0; i < cast_array.length; i++) |
| cast_array[i] = readObject(); |
| } |
| } |
| |
| private void readFields (Object obj, ObjectStreamClass stream_osc) |
| throws ClassNotFoundException, IOException |
| { |
| ObjectStreamField[] fields = stream_osc.fieldMapping; |
| |
| for (int i = 0; i < fields.length; i += 2) |
| { |
| ObjectStreamField stream_field = fields[i]; |
| ObjectStreamField real_field = fields[i + 1]; |
| boolean read_value = (stream_field != null && stream_field.getOffset() >= 0 && stream_field.isToSet()); |
| boolean set_value = (real_field != null && real_field.isToSet()); |
| String field_name; |
| char type; |
| |
| if (stream_field != null) |
| { |
| field_name = stream_field.getName(); |
| type = stream_field.getTypeCode(); |
| } |
| else |
| { |
| field_name = real_field.getName(); |
| type = real_field.getTypeCode(); |
| } |
| |
| switch(type) |
| { |
| case 'Z': |
| { |
| boolean value = |
| read_value ? this.realInputStream.readBoolean() : false; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setBooleanField(obj, value); |
| break; |
| } |
| case 'B': |
| { |
| byte value = |
| read_value ? this.realInputStream.readByte() : 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setByteField(obj, value); |
| break; |
| } |
| case 'C': |
| { |
| char value = |
| read_value ? this.realInputStream.readChar(): 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setCharField(obj, value); |
| break; |
| } |
| case 'D': |
| { |
| double value = |
| read_value ? this.realInputStream.readDouble() : 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setDoubleField(obj, value); |
| break; |
| } |
| case 'F': |
| { |
| float value = |
| read_value ? this.realInputStream.readFloat() : 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setFloatField(obj, value); |
| break; |
| } |
| case 'I': |
| { |
| int value = |
| read_value ? this.realInputStream.readInt() : 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setIntField(obj, value); |
| break; |
| } |
| case 'J': |
| { |
| long value = |
| read_value ? this.realInputStream.readLong() : 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setLongField(obj, value); |
| break; |
| } |
| case 'S': |
| { |
| short value = |
| read_value ? this.realInputStream.readShort() : 0; |
| if (dump && read_value && set_value) |
| dumpElementln(" " + field_name + ": " + value); |
| if (set_value) |
| real_field.setShortField(obj, value); |
| break; |
| } |
| case 'L': |
| case '[': |
| { |
| Object value = |
| read_value ? readObject() : null; |
| if (set_value) |
| real_field.setObjectField(obj, value); |
| break; |
| } |
| default: |
| throw new InternalError("Invalid type code: " + type); |
| } |
| } |
| } |
| |
| // Toggles writing primitive data to block-data buffer. |
| private boolean setBlockDataMode (boolean on) |
| { |
| boolean oldmode = this.readDataFromBlock; |
| this.readDataFromBlock = on; |
| |
| if (on) |
| this.dataInputStream = this.blockDataInput; |
| else |
| this.dataInputStream = this.realInputStream; |
| return oldmode; |
| } |
| |
| // returns a new instance of REAL_CLASS that has been constructed |
| // only to the level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS) |
| private Object newObject (Class real_class, Constructor constructor) |
| throws ClassNotFoundException, IOException |
| { |
| if (constructor == null) |
| throw new InvalidClassException("Missing accessible no-arg base class constructor for " + real_class.getName()); |
| try |
| { |
| return allocateObject(real_class, constructor.getDeclaringClass(), constructor); |
| } |
| catch (InstantiationException e) |
| { |
| throw new ClassNotFoundException |
| ("Instance of " + real_class + " could not be created"); |
| } |
| } |
| |
| // runs all registered ObjectInputValidations in prioritized order |
| // on OBJ |
| private void invokeValidators() throws InvalidObjectException |
| { |
| Object[] validators = new Object[this.validators.size()]; |
| this.validators.copyInto (validators); |
| Arrays.sort (validators); |
| |
| try |
| { |
| for (int i=0; i < validators.length; i++) |
| ((ObjectInputValidation)validators[i]).validateObject(); |
| } |
| finally |
| { |
| this.validators.removeAllElements(); |
| } |
| } |
| |
| /** |
| * This native method is used to get access to the protected method |
| * of the same name in SecurityManger. |
| * |
| * @param sm SecurityManager instance which should be called. |
| * @return The current class loader in the calling stack. |
| */ |
| private static native ClassLoader currentClassLoader (SecurityManager sm); |
| |
| private void callReadMethod (Method readObject, Class klass, Object obj) |
| throws ClassNotFoundException, IOException |
| { |
| try |
| { |
| readObject.invoke(obj, new Object[] { this }); |
| } |
| catch (InvocationTargetException x) |
| { |
| /* Rethrow if possible. */ |
| Throwable exception = x.getTargetException(); |
| if (exception instanceof RuntimeException) |
| throw (RuntimeException) exception; |
| if (exception instanceof IOException) |
| throw (IOException) exception; |
| if (exception instanceof ClassNotFoundException) |
| throw (ClassNotFoundException) exception; |
| |
| throw new IOException("Exception thrown from readObject() on " + |
| klass + ": " + exception.getClass().getName()); |
| } |
| catch (Exception x) |
| { |
| throw new IOException("Failure invoking readObject() on " + |
| klass + ": " + x.getClass().getName()); |
| } |
| |
| // Invalidate fields which has been read through readFields. |
| prereadFields = null; |
| } |
| |
| private native Object allocateObject(Class clazz, Class constr_clazz, Constructor constructor) |
| throws InstantiationException; |
| |
| private static final int BUFFER_SIZE = 1024; |
| |
| private DataInputStream realInputStream; |
| private DataInputStream dataInputStream; |
| private DataInputStream blockDataInput; |
| private int blockDataPosition; |
| private int blockDataBytes; |
| private byte[] blockData; |
| private boolean useSubclassMethod; |
| private int nextOID; |
| private boolean resolveEnabled; |
| private Hashtable objectLookupTable; |
| private Object currentObject; |
| private ObjectStreamClass currentObjectStreamClass; |
| private boolean readDataFromBlock; |
| private boolean isDeserializing; |
| private boolean fieldsAlreadyRead; |
| private Vector validators; |
| private Hashtable classLookupTable; |
| private GetField prereadFields; |
| |
| private ClassLoader callersClassLoader; |
| private static boolean dump; |
| |
| // The nesting depth for debugging output |
| private int depth = 0; |
| |
| private void dumpElement (String msg) |
| { |
| System.out.print(msg); |
| } |
| |
| private void dumpElementln (String msg) |
| { |
| System.out.println(msg); |
| for (int i = 0; i < depth; i++) |
| System.out.print (" "); |
| System.out.print (Thread.currentThread() + ": "); |
| } |
| |
| static |
| { |
| if (Configuration.INIT_LOAD_LIBRARY) |
| { |
| System.loadLibrary ("javaio"); |
| } |
| } |
| |
| // used to keep a prioritized list of object validators |
| private static final class ValidatorAndPriority implements Comparable |
| { |
| int priority; |
| ObjectInputValidation validator; |
| |
| ValidatorAndPriority (ObjectInputValidation validator, int priority) |
| { |
| this.priority = priority; |
| this.validator = validator; |
| } |
| |
| public int compareTo (Object o) |
| { |
| ValidatorAndPriority vap = (ValidatorAndPriority)o; |
| return this.priority - vap.priority; |
| } |
| } |
| } |
| |