Mercurial > jdk8-mips64-public > corba / file revision

 /*

  * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * This code 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

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  */

 /*

  * Licensed Materials - Property of IBM

  * RMI-IIOP v1.0

  * Copyright IBM Corp. 1998 1999  All Rights Reserved

  *

  */

 package com.sun.corba.se.impl.orbutil;

 import java.security.MessageDigest;

 import java.security.NoSuchAlgorithmException;

 import java.security.DigestOutputStream;

 import java.security.AccessController;

 import java.security.PrivilegedExceptionAction;

 import java.security.PrivilegedActionException;

 import java.security.PrivilegedAction;

 import java.lang.reflect.Modifier;

 import java.lang.reflect.Array;

 import java.lang.reflect.Field;

 import java.lang.reflect.Member;

 import java.lang.reflect.Method;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.Proxy;

 import java.lang.reflect.InvocationTargetException;

 import java.io.IOException;

 import java.io.DataOutputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.InvalidClassException;

 import java.io.Serializable;

 import java.io.Externalizable;

 import java.util.Arrays;

 import java.util.Comparator;

 import java.util.Hashtable;

 import org.omg.CORBA.ValueMember;

 import com.sun.corba.se.impl.io.ValueUtility;

 import com.sun.corba.se.impl.io.ObjectStreamClass;

 /**

  * This is duplicated here to preserve the JDK 1.3.1FCS behavior

  * of calculating the OMG hash code incorrectly when serialPersistentFields

  * is used, but some of the fields no longer exist in the class itself.

  *

  * We have to duplicate it since we aren't allowed to modify the

  * com.sun.corba.se.impl.io version further, and can't make it

  * public outside of its package for security reasons.

  */

 /**

  * A ObjectStreamClass_1_3_1 describes a class that can be serialized to a stream

  * or a class that was serialized to a stream.  It contains the name

  * and the serialVersionUID of the class.

  * <br>

  * The ObjectStreamClass_1_3_1 for a specific class loaded in this Java VM can

  * be found using the lookup method.

  *

  * @author  Roger Riggs

  * @since   JDK1.1

  */

 public class ObjectStreamClass_1_3_1 implements java.io.Serializable {

     public static final long kDefaultUID = -1;

     private static Object noArgsList[] = {};

     private static Class<?> noTypesList[] = {};

     private static Hashtable translatedFields;

     /** Find the descriptor for a class that can be serialized.  Null

      * is returned if the specified class does not implement

      * java.io.Serializable or java.io.Externalizable.

      */

     static final ObjectStreamClass_1_3_1 lookup(Class<?> cl)

     {

         ObjectStreamClass_1_3_1 desc = lookupInternal(cl);

         if (desc.isSerializable() || desc.isExternalizable())

             return desc;

         return null;

     }

     /*

      * Find the class descriptor for the specified class.

      * Package access only so it can be called from ObjectIn/OutStream.

      */

     static ObjectStreamClass_1_3_1 lookupInternal(Class<?> cl)

     {

         /* Synchronize on the hashtable so no two threads will do

          * this at the same time.

          */

         ObjectStreamClass_1_3_1 desc = null;

         synchronized (descriptorFor) {

             /* Find the matching descriptor if it already known */

             desc = findDescriptorFor(cl);

             if (desc != null) {

                 return desc;

             }

                 /* Check if it's serializable */

                 boolean serializable = Serializable.class.isAssignableFrom(cl);

                 /* If the class is only Serializable,

                  * lookup the descriptor for the superclass.

                  */

                 ObjectStreamClass_1_3_1 superdesc = null;

                 if (serializable) {

                     Class<?> superclass = cl.getSuperclass();

                     if (superclass != null)

                         superdesc = lookup(superclass);

                 }

                 /* Check if its' externalizable.

                  * If it's Externalizable, clear the serializable flag.

                  * Only one or the other may be set in the protocol.

                  */

                 boolean externalizable = false;

                 if (serializable) {

                     externalizable =

                         ((superdesc != null) && superdesc.isExternalizable()) ||

                         Externalizable.class.isAssignableFrom(cl);

                     if (externalizable) {

                         serializable = false;

                     }

                 }

             /* Create a new version descriptor,

              * it put itself in the known table.

              */

             desc = new ObjectStreamClass_1_3_1(cl, superdesc,

                                          serializable, externalizable);

         }

         desc.init();

         return desc;

     }

     /**

      * The name of the class described by this descriptor.

      */

     public final String getName() {

         return name;

     }

     /**

      * Return the serialVersionUID for this class.

      * The serialVersionUID defines a set of classes all with the same name

      * that have evolved from a common root class and agree to be serialized

      * and deserialized using a common format.

      */

     public static final long getSerialVersionUID( java.lang.Class<?> clazz) {

         ObjectStreamClass_1_3_1 theosc = ObjectStreamClass_1_3_1.lookup( clazz );

         if( theosc != null )

         {

                 return theosc.getSerialVersionUID( );

         }

         return 0;

     }

     /**

      * Return the serialVersionUID for this class.

      * The serialVersionUID defines a set of classes all with the same name

      * that have evolved from a common root class and agree to be serialized

      * and deserialized using a common format.

      */

     public final long getSerialVersionUID() {

         return suid;

     }

     /**

      * Return the serialVersionUID string for this class.

      * The serialVersionUID defines a set of classes all with the same name

      * that have evolved from a common root class and agree to be serialized

      * and deserialized using a common format.

      */

     public final String getSerialVersionUIDStr() {

         if (suidStr == null)

             suidStr = Long.toHexString(suid).toUpperCase();

         return suidStr;

     }

     /**

      * Return the actual (computed) serialVersionUID for this class.

      */

     public static final long getActualSerialVersionUID( java.lang.Class<?> clazz )

     {

         ObjectStreamClass_1_3_1 theosc = ObjectStreamClass_1_3_1.lookup( clazz );

         if( theosc != null )

         {

                 return theosc.getActualSerialVersionUID( );

         }

         return 0;

     }

     /**

      * Return the actual (computed) serialVersionUID for this class.

      */

     public final long getActualSerialVersionUID() {

         return actualSuid;

     }

     /**

      * Return the actual (computed) serialVersionUID for this class.

      */

     public final String getActualSerialVersionUIDStr() {

         if (actualSuidStr == null)

             actualSuidStr = Long.toHexString(actualSuid).toUpperCase();

         return actualSuidStr;

     }

     /**

      * Return the class in the local VM that this version is mapped to.

      * Null is returned if there is no corresponding local class.

      */

     public final Class<?> forClass() {

         return ofClass;

     }

     /**

      * Return an array of the fields of this serializable class.

      * @return an array containing an element for each persistent

      * field of this class. Returns an array of length zero if

      * there are no fields.

      * @since JDK1.2

      */

     public ObjectStreamField[] getFields() {

         // Return a copy so the caller can't change the fields.

         if (fields.length > 0) {

             ObjectStreamField[] dup = new ObjectStreamField[fields.length];

             System.arraycopy(fields, 0, dup, 0, fields.length);

             return dup;

         } else {

             return fields;

         }

     }

     public boolean hasField(ValueMember field){

         for (int i = 0; i < fields.length; i++){

             try{

                 if (fields[i].getName().equals(field.name)) {

                     if (fields[i].getSignature().equals(ValueUtility.getSignature(field)))

                         return true;

                 }

             }

             catch(Throwable t){}

         }

         return false;

     }

     /* Avoid unnecessary allocations. */

     final ObjectStreamField[] getFieldsNoCopy() {

         return fields;

     }

     /**

      * Get the field of this class by name.

      * @return The ObjectStreamField object of the named field or null if there

      * is no such named field.

      */

     public final ObjectStreamField getField(String name) {

         /* Binary search of fields by name.

          */

         for (int i = fields.length-1; i >= 0; i--) {

             if (name.equals(fields[i].getName())) {

                 return fields[i];

             }

         }

         return null;

     }

     public Serializable writeReplace(Serializable value) {

         if (writeReplaceObjectMethod != null) {

             try {

                 return (Serializable) writeReplaceObjectMethod.invoke(value,noArgsList);

             }

             catch(Throwable t) {

                 throw new RuntimeException(t.getMessage());

             }

         }

         else return value;

     }

     public Object readResolve(Object value) {

         if (readResolveObjectMethod != null) {

             try {

                 return readResolveObjectMethod.invoke(value,noArgsList);

             }

             catch(Throwable t) {

                 throw new RuntimeException(t.getMessage());

             }

         }

         else return value;

     }

     /**

      * Return a string describing this ObjectStreamClass_1_3_1.

      */

     public final String toString() {

         StringBuffer sb = new StringBuffer();

         sb.append(name);

         sb.append(": static final long serialVersionUID = ");

         sb.append(Long.toString(suid));

         sb.append("L;");

         return sb.toString();

     }

     /*

      * Create a new ObjectStreamClass_1_3_1 from a loaded class.

      * Don't call this directly, call lookup instead.

      */

     private ObjectStreamClass_1_3_1(java.lang.Class<?> cl, ObjectStreamClass_1_3_1 superdesc,

                               boolean serial, boolean extern)

     {

         ofClass = cl;           /* created from this class */

         if (Proxy.isProxyClass(cl)) {

             forProxyClass = true;

         }

         name = cl.getName();

         superclass = superdesc;

         serializable = serial;

         if (!forProxyClass) {

             // proxy classes are never externalizable

             externalizable = extern;

         }

         /*

          * Enter this class in the table of known descriptors.

          * Otherwise, when the fields are read it may recurse

          * trying to find the descriptor for itself.

          */

         insertDescriptorFor(this);

         /*

          * The remainder of initialization occurs in init(), which is called

          * after the lock on the global class descriptor table has been

          * released.

          */

     }

     /*

      * Initialize class descriptor.  This method is only invoked on class

      * descriptors created via calls to lookupInternal().  This method is kept

      * separate from the ObjectStreamClass_1_3_1 constructor so that lookupInternal

      * does not have to hold onto a global class descriptor table lock while the

      * class descriptor is being initialized (see bug 4165204).

      */

     private void init() {

       synchronized (lock) {

         final Class<?> cl = ofClass;

         if (fields != null) // already initialized

                 return;

         if (!serializable ||

             externalizable ||

             forProxyClass ||

             name.equals("java.lang.String")) {

             fields = NO_FIELDS;

         } else if (serializable) {

             /* Ask for permission to override field access checks.

              */

             AccessController.doPrivileged(new PrivilegedAction() {

                 public Object run() {

                 /* Fill in the list of persistent fields.

                  * If it is declared, use the declared serialPersistentFields.

                  * Otherwise, extract the fields from the class itself.

                  */

                 try {

                     Field pf = cl.getDeclaredField("serialPersistentFields");

                     // serial bug 7; the serialPersistentFields were not

                     // being read and stored as Accessible bit was not set

                     pf.setAccessible(true);

                     // serial bug 7; need to find if the field is of type

                     // java.io.ObjectStreamField

                     java.io.ObjectStreamField[] f =

                            (java.io.ObjectStreamField[])pf.get(cl);

                     int mods = pf.getModifiers();

                     if ((Modifier.isPrivate(mods)) &&

                         (Modifier.isStatic(mods)) &&

                         (Modifier.isFinal(mods)))

                     {

                         fields = (ObjectStreamField[])translateFields((Object[])pf.get(cl));

                     }

                 } catch (NoSuchFieldException e) {

                     fields = null;

                 } catch (IllegalAccessException e) {

                     fields = null;

                 } catch (IllegalArgumentException e) {

                     fields = null;

                 } catch (ClassCastException e) {

                     /* Thrown if a field serialPersistentField exists

                      * but it is not of type ObjectStreamField.

                      */

                     fields = null;

                 }

                 if (fields == null) {

                     /* Get all of the declared fields for this

                      * Class. setAccessible on all fields so they

                      * can be accessed later.  Create a temporary

                      * ObjectStreamField array to hold each

                      * non-static, non-transient field. Then copy the

                      * temporary array into an array of the correct

                      * size once the number of fields is known.

                      */

                     Field[] actualfields = cl.getDeclaredFields();

                     int numFields = 0;

                     ObjectStreamField[] tempFields =

                         new ObjectStreamField[actualfields.length];

                     for (int i = 0; i < actualfields.length; i++) {

                         int modifiers = actualfields[i].getModifiers();

                         if (!Modifier.isStatic(modifiers) &&

                             !Modifier.isTransient(modifiers)) {

                             tempFields[numFields++] =

                                 new ObjectStreamField(actualfields[i]);

                         }

                     }

                     fields = new ObjectStreamField[numFields];

                     System.arraycopy(tempFields, 0, fields, 0, numFields);

                 } else {

                     // For each declared persistent field, look for an actual

                     // reflected Field. If there is one, make sure it's the correct

                     // type and cache it in the ObjectStreamClass_1_3_1 for that field.

                     for (int j = fields.length-1; j >= 0; j--) {

                         try {

                             Field reflField = cl.getDeclaredField(fields[j].getName());

                             if (fields[j].getType() == reflField.getType()) {

                                 // reflField.setAccessible(true);

                                 fields[j].setField(reflField);

                             }

                         } catch (NoSuchFieldException e) {

                             // Nothing to do

                         }

                     }

                 }

                 return null;

             }

             });

             if (fields.length > 1)

                 Arrays.sort(fields);

             /* Set up field data for use while writing using the API api. */

             computeFieldInfo();

         }

         /* Get the serialVersionUID from the class.

          * It uses the access override mechanism so make sure

          * the field objects is only used here.

          *

          * NonSerializable classes have a serialVerisonUID of 0L.

          */

          if (isNonSerializable()) {

              suid = 0L;

          } else {

              // Lookup special Serializable members using reflection.

              AccessController.doPrivileged(new PrivilegedAction() {

                 public Object run() {

                 if (forProxyClass) {

                     // proxy classes always have serialVersionUID of 0L

                     suid = 0L;

                 } else {

                     try {

                         final Field f = cl.getDeclaredField("serialVersionUID");

                         int mods = f.getModifiers();

                     // SerialBug 5:  static final SUID should be read

                         if (Modifier.isStatic(mods) &&

                             Modifier.isFinal(mods) ) {

                             f.setAccessible(true);

                             suid = f.getLong(cl);

                             // get rid of native code

                             // suid = getSerialVersionUIDField(cl);

                     // SerialBug 2: should be computed after writeObject

                     // actualSuid = computeStructuralUID(cl);

                         } else {

                             suid = ObjectStreamClass.getSerialVersionUID(cl);

                             // SerialBug 2: should be computed after writeObject

                             // actualSuid = computeStructuralUID(cl);

                         }

                     } catch (NoSuchFieldException ex) {

                         suid = ObjectStreamClass.getSerialVersionUID(cl);

                         // SerialBug 2: should be computed after writeObject

                         // actualSuid = computeStructuralUID(cl);

                     } catch (IllegalAccessException ex) {

                         suid = ObjectStreamClass.getSerialVersionUID(cl);

                     }

                 }

                 try {

                     writeReplaceObjectMethod = cl.getDeclaredMethod("writeReplace", noTypesList);

                     if (Modifier.isStatic(writeReplaceObjectMethod.getModifiers())) {

                         writeReplaceObjectMethod = null;

                     } else {

                         writeReplaceObjectMethod.setAccessible(true);

                     }

                 } catch (NoSuchMethodException e2) {

                 }

                 try {

                     readResolveObjectMethod = cl.getDeclaredMethod("readResolve", noTypesList);

                     if (Modifier.isStatic(readResolveObjectMethod.getModifiers())) {

                        readResolveObjectMethod = null;

                     } else {

                        readResolveObjectMethod.setAccessible(true);

                     }

                 } catch (NoSuchMethodException e2) {

                 }

                 /* Cache lookup of writeObject and readObject for

                  * Serializable classes. (Do not lookup for

                  * Externalizable)

                  */

                 if (serializable && !forProxyClass) {

                     /* Look for the writeObject method

                      * Set the accessible flag on it here. ObjectOutputStream

                      * will call it as necessary.

                      */

                     try {

                       Class<?>[] args = {java.io.ObjectOutputStream.class};

                       writeObjectMethod = cl.getDeclaredMethod("writeObject", args);

                       hasWriteObjectMethod = true;

                       int mods = writeObjectMethod.getModifiers();

                       // Method must be private and non-static

                       if (!Modifier.isPrivate(mods) ||

                         Modifier.isStatic(mods)) {

                         writeObjectMethod = null;

                         hasWriteObjectMethod = false;

                       }

                     } catch (NoSuchMethodException e) {

                     }

                     /* Look for the readObject method

                      * set the access override and save the reference for

                      * ObjectInputStream so it can all the method directly.

                      */

                     try {

                       Class<?>[] args = {java.io.ObjectInputStream.class};

                       readObjectMethod = cl.getDeclaredMethod("readObject", args);

                       int mods = readObjectMethod.getModifiers();

                       // Method must be private and non-static

                       if (!Modifier.isPrivate(mods) ||

                         Modifier.isStatic(mods)) {

                         readObjectMethod = null;

                       }

                     } catch (NoSuchMethodException e) {

                     }

                     // Compute the structural UID.  This must be done after the

                     // calculation for writeObject.  Fixed 4/20/2000, eea1

                     // SerialBug 2: to have correct value in RepId

                 }

                 return null;

             }

           });

         }

         actualSuid = computeStructuralUID(this, cl);

       }

     }

     /*

      * Create an empty ObjectStreamClass_1_3_1 for a class about to be read.

      * This is separate from read so ObjectInputStream can assign the

      * wire handle early, before any nested ObjectStreamClass_1_3_1 might

      * be read.

      */

     ObjectStreamClass_1_3_1(String n, long s) {

         name = n;

         suid = s;

         superclass = null;

     }

     private static Object[] translateFields(Object objs[])

         throws NoSuchFieldException {

         try{

             java.io.ObjectStreamField fields[] = (java.io.ObjectStreamField[])objs;

             Object translation[] = null;

             if (translatedFields == null)

                 translatedFields = new Hashtable();

             translation = (Object[])translatedFields.get(fields);

             if (translation != null)

                 return translation;

             else {

                 Class<?> osfClass = com.sun.corba.se.impl.orbutil.ObjectStreamField.class;

                 translation = (Object[])java.lang.reflect.Array.newInstance(osfClass, objs.length);

                 Object arg[] = new Object[2];

                 Class<?> types[] = {String.class, Class.class};

                 Constructor constructor = osfClass.getDeclaredConstructor(types);

                 for (int i = fields.length -1; i >= 0; i--){

                     arg[0] = fields[i].getName();

                     arg[1] = fields[i].getType();

                     translation[i] = constructor.newInstance(arg);

                 }

                 translatedFields.put(fields, translation);

             }

             return (Object[])translation;

         }

         catch(Throwable t){

             throw new NoSuchFieldException();

         }

     }

     /* Compare the base class names of streamName and localName.

      *

      * @return  Return true iff the base class name compare.

      * @parameter streamName    Fully qualified class name.

      * @parameter localName     Fully qualified class name.

      * @parameter pkgSeparator  class names use either '.' or '/'.

      *

      * Only compare base class name to allow package renaming.

      */

     static boolean compareClassNames(String streamName,

                                      String localName,

                                      char pkgSeparator) {

         /* compare the class names, stripping off package names. */

         int streamNameIndex = streamName.lastIndexOf(pkgSeparator);

         if (streamNameIndex < 0)

             streamNameIndex = 0;

         int localNameIndex = localName.lastIndexOf(pkgSeparator);

         if (localNameIndex < 0)

             localNameIndex = 0;

         return streamName.regionMatches(false, streamNameIndex,

                                         localName, localNameIndex,

                                         streamName.length() - streamNameIndex);

     }

     /*

      * Compare the types of two class descriptors.

      * They match if they have the same class name and suid

      */

     final boolean typeEquals(ObjectStreamClass_1_3_1 other) {

         return (suid == other.suid) &&

             compareClassNames(name, other.name, '.');

     }

     /*

      * Return the superclass descriptor of this descriptor.

      */

     final void setSuperclass(ObjectStreamClass_1_3_1 s) {

         superclass = s;

     }

     /*

      * Return the superclass descriptor of this descriptor.

      */

     final ObjectStreamClass_1_3_1 getSuperclass() {

         return superclass;

     }

     /*

      * Return whether the class has a writeObject method

      */

     final boolean hasWriteObject() {

         return hasWriteObjectMethod;

     }

     final boolean isCustomMarshaled() {

         return (hasWriteObject() || isExternalizable());

     }

     /*

      * Return true if all instances of 'this' Externalizable class

      * are written in block-data mode from the stream that 'this' was read

      * from. <p>

      *

      * In JDK 1.1, all Externalizable instances are not written

      * in block-data mode.

      * In JDK 1.2, all Externalizable instances, by default, are written

      * in block-data mode and the Externalizable instance is terminated with

      * tag TC_ENDBLOCKDATA. Change enabled the ability to skip Externalizable

      * instances.

      *

      * IMPLEMENTATION NOTE:

      *   This should have been a mode maintained per stream; however,

      *   for compatibility reasons, it was only possible to record

      *   this change per class. All Externalizable classes within

      *   a given stream should either have this mode enabled or

      *   disabled. This is enforced by not allowing the PROTOCOL_VERSION

      *   of a stream to he changed after any objects have been written.

      *

      * @see ObjectOutputStream#useProtocolVersion

      * @see ObjectStreamConstants#PROTOCOL_VERSION_1

      * @see ObjectStreamConstants#PROTOCOL_VERSION_2

      *

      * @since JDK 1.2

      */

     boolean hasExternalizableBlockDataMode() {

         return hasExternalizableBlockData;

     }

     /*

      * Return the ObjectStreamClass_1_3_1 of the local class this one is based on.

      */

     final ObjectStreamClass_1_3_1 localClassDescriptor() {

         return localClassDesc;

     }

     /*

      * Get the Serializability of the class.

      */

     boolean isSerializable() {

         return serializable;

     }

     /*

      * Get the externalizability of the class.

      */

     boolean isExternalizable() {

         return externalizable;

     }

     boolean isNonSerializable() {

         return ! (externalizable || serializable);

     }

     /*

      * Calculate the size of the array needed to store primitive data and the

      * number of object references to read when reading from the input

      * stream.

      */

     private void computeFieldInfo() {

         primBytes = 0;

         objFields = 0;

         for (int i = 0; i < fields.length; i++ ) {

             switch (fields[i].getTypeCode()) {

             case 'B':

             case 'Z':

                 primBytes += 1;

                 break;

             case 'C':

             case 'S':

                 primBytes += 2;

                 break;

             case 'I':

             case 'F':

                 primBytes += 4;

                 break;

             case 'J':

             case 'D' :

                 primBytes += 8;

                 break;

             case 'L':

             case '[':

                 objFields += 1;

                 break;

             }

         }

     }

     private static long computeStructuralUID(ObjectStreamClass_1_3_1 osc, Class<?> cl) {

         ByteArrayOutputStream devnull = new ByteArrayOutputStream(512);

         long h = 0;

         try {

             if ((!java.io.Serializable.class.isAssignableFrom(cl)) ||

                 (cl.isInterface())){

                 return 0;

             }

             if (java.io.Externalizable.class.isAssignableFrom(cl)) {

                 return 1;

             }

             MessageDigest md = MessageDigest.getInstance("SHA");

             DigestOutputStream mdo = new DigestOutputStream(devnull, md);

             DataOutputStream data = new DataOutputStream(mdo);

             // Get SUID of parent

             Class<?> parent = cl.getSuperclass();

             if ((parent != null))

             // SerialBug 1; acc. to spec the one for

             // java.lang.object

             // should be computed and put

             //     && (parent != java.lang.Object.class))

             {

                                 //data.writeLong(computeSerialVersionUID(null,parent));

                 data.writeLong(computeStructuralUID(lookup(parent), parent));

             }

             if (osc.hasWriteObject())

                 data.writeInt(2);

             else

                 data.writeInt(1);

             /* Sort the field names to get a deterministic order */

             // Field[] field = ObjectStreamClass_1_3_1.getDeclaredFields(cl);

             ObjectStreamField[] fields = osc.getFields();

             // Must make sure that the Field array we allocate

             // below is exactly the right size.  Bug fix for

             // 4397133.

             int numNonNullFields = 0;

             for (int i = 0; i < fields.length; i++)

                 if (fields[i].getField() != null)

                     numNonNullFields++;

             Field [] field = new java.lang.reflect.Field[numNonNullFields];

             for (int i = 0, fieldNum = 0; i < fields.length; i++) {

                 if (fields[i].getField() != null) {

                     field[fieldNum++] = fields[i].getField();

                 }

             }

             if (field.length > 1)

                 Arrays.sort(field, compareMemberByName);

             for (int i = 0; i < field.length; i++) {

                 Field f = field[i];

                                 /* Include in the hash all fields except those that are

                                  * transient

                                  */

                 int m = f.getModifiers();

                 //Serial 6

                 //if (Modifier.isTransient(m) || Modifier.isStatic(m))

                 // spec reference 00-01-06.pdf, 1.3.5.6, states non-static

                 // non-transient, public fields are mapped to Java IDL.

                 //

                 // Here's the quote from the first paragraph:

                 // Java non-static non-transient public fields are mapped to

                 // OMG IDL public data members, and other Java fields are

                 // not mapped.

                 // if (Modifier.isTransient(m) || Modifier.isStatic(m))

                 //     continue;

                 data.writeUTF(f.getName());

                 data.writeUTF(getSignature(f.getType()));

             }

             /* Compute the hash value for this class.

              * Use only the first 64 bits of the hash.

              */

             data.flush();

             byte hasharray[] = md.digest();

             // int minimum = Math.min(8, hasharray.length);

             // SerialBug 3: SHA computation is wrong; for loop reversed

             //for (int i = minimum; i > 0; i--)

             for (int i = 0; i < Math.min(8, hasharray.length); i++) {

                 h += (long)(hasharray[i] & 255) << (i * 8);

             }

         } catch (IOException ignore) {

             /* can't happen, but be deterministic anyway. */

             h = -1;

         } catch (NoSuchAlgorithmException complain) {

             throw new SecurityException(complain.getMessage());

         }

         return h;

     }

     /**

      * Compute the JVM signature for the class.

      */

     static String getSignature(Class<?> clazz) {

         String type = null;

         if (clazz.isArray()) {

             Class<?> cl = clazz;

             int dimensions = 0;

             while (cl.isArray()) {

                 dimensions++;

                 cl = cl.getComponentType();

             }

             StringBuffer sb = new StringBuffer();

             for (int i = 0; i < dimensions; i++) {

                 sb.append("[");

             }

             sb.append(getSignature(cl));

             type = sb.toString();

         } else if (clazz.isPrimitive()) {

             if (clazz == Integer.TYPE) {

                 type = "I";

             } else if (clazz == Byte.TYPE) {

                 type = "B";

             } else if (clazz == Long.TYPE) {

                 type = "J";

             } else if (clazz == Float.TYPE) {

                 type = "F";

             } else if (clazz == Double.TYPE) {

                 type = "D";

             } else if (clazz == Short.TYPE) {

                 type = "S";

             } else if (clazz == Character.TYPE) {

                 type = "C";

             } else if (clazz == Boolean.TYPE) {

                 type = "Z";

             } else if (clazz == Void.TYPE) {

                 type = "V";

             }

         } else {

             type = "L" + clazz.getName().replace('.', '/') + ";";

         }

         return type;

     }

     /*

      * Compute the JVM method descriptor for the method.

      */

     static String getSignature(Method meth) {

         StringBuffer sb = new StringBuffer();

         sb.append("(");

         Class<?>[] params = meth.getParameterTypes(); // avoid clone

         for (int j = 0; j < params.length; j++) {

             sb.append(getSignature(params[j]));

         }

         sb.append(")");

         sb.append(getSignature(meth.getReturnType()));

         return sb.toString();

     }

     /*

      * Compute the JVM constructor descriptor for the constructor.

      */

     static String getSignature(Constructor cons) {

         StringBuffer sb = new StringBuffer();

         sb.append("(");

         Class<?>[] params = cons.getParameterTypes(); // avoid clone

         for (int j = 0; j < params.length; j++) {

             sb.append(getSignature(params[j]));

         }

         sb.append(")V");

         return sb.toString();

     }

     /*

      * Cache of Class -> ClassDescriptor Mappings.

      */

     static private ObjectStreamClassEntry[] descriptorFor = new ObjectStreamClassEntry[61];

     /*

      * findDescriptorFor a Class.  This looks in the cache for a

      * mapping from Class -> ObjectStreamClass mappings.  The hashCode

      * of the Class is used for the lookup since the Class is the key.

      * The entries are extended from java.lang.ref.SoftReference so the

      * gc will be able to free them if needed.

      */

     private static ObjectStreamClass_1_3_1 findDescriptorFor(Class<?> cl) {

         int hash = cl.hashCode();

         int index = (hash & 0x7FFFFFFF) % descriptorFor.length;

         ObjectStreamClassEntry e;

         ObjectStreamClassEntry prev;

         /* Free any initial entries whose refs have been cleared */

         while ((e = descriptorFor[index]) != null && e.get() == null) {

             descriptorFor[index] = e.next;

         }

         /* Traverse the chain looking for a descriptor with ofClass == cl.

          * unlink entries that are unresolved.

          */

         prev = e;

         while (e != null ) {

             ObjectStreamClass_1_3_1 desc = (ObjectStreamClass_1_3_1)(e.get());

             if (desc == null) {

                 // This entry has been cleared,  unlink it

                 prev.next = e.next;

             } else {

                 if (desc.ofClass == cl)

                     return desc;

                 prev = e;

             }

             e = e.next;

         }

         return null;

     }

     /*

      * insertDescriptorFor a Class -> ObjectStreamClass_1_3_1 mapping.

      */

     private static void insertDescriptorFor(ObjectStreamClass_1_3_1 desc) {

         // Make sure not already present

         if (findDescriptorFor(desc.ofClass) != null) {

             return;

         }

         int hash = desc.ofClass.hashCode();

         int index = (hash & 0x7FFFFFFF) % descriptorFor.length;

         ObjectStreamClassEntry e = new ObjectStreamClassEntry(desc);

         e.next = descriptorFor[index];

         descriptorFor[index] = e;

     }

     private static Field[] getDeclaredFields(final Class clz) {

         return (Field[]) AccessController.doPrivileged(new PrivilegedAction() {

             public Object run() {

                 return clz.getDeclaredFields();

             }

         });

     }

     /*

      * The name of this descriptor

      */

     private String name;

     /*

      * The descriptor of the supertype.

      */

     private ObjectStreamClass_1_3_1 superclass;

     /*

      * Flags for Serializable and Externalizable.

      */

     private boolean serializable;

     private boolean externalizable;

     /*

      * Array of persistent fields of this class, sorted by

      * type and name.

      */

     private ObjectStreamField[] fields;

     /*

      * Class that is a descriptor for in this virtual machine.

      */

     private Class<?> ofClass;

     /*

      * True if descriptor for a proxy class.

      */

     boolean forProxyClass;

     /*

      * SerialVersionUID for this class.

      */

     private long suid = kDefaultUID;

     private String suidStr = null;

     /*

      * Actual (computed) SerialVersionUID for this class.

      */

     private long actualSuid = kDefaultUID;

     private String actualSuidStr = null;

     /*

      * The total number of bytes of primitive fields.

      * The total number of object fields.

      */

     int primBytes;

     int objFields;

     /* Internal lock object. */

     private Object lock = new Object();

     /* True if this class has/had a writeObject method */

     private boolean hasWriteObjectMethod;

     /* In JDK 1.1, external data was not written in block mode.

      * As of JDK 1.2, external data is written in block data mode. This

      * flag enables JDK 1.2 to be able to read JDK 1.1 written external data.

      *

      * @since JDK 1.2

      */

     private boolean hasExternalizableBlockData;

     Method writeObjectMethod;

     Method readObjectMethod;

     private transient Method writeReplaceObjectMethod;

     private transient Method readResolveObjectMethod;

     /*

      * ObjectStreamClass_1_3_1 that this one was built from.

      */

     private ObjectStreamClass_1_3_1 localClassDesc;

     /* Get the private static final field for serial version UID */

     // private static native long getSerialVersionUIDField(Class cl);

     /** use serialVersionUID from JDK 1.1. for interoperability */

     private static final long serialVersionUID = -6120832682080437368L;

     /**

      * Set serialPersistentFields of a Serializable class to this value to

      * denote that the class has no Serializable fields.

      */

     public static final ObjectStreamField[] NO_FIELDS =

         new ObjectStreamField[0];

     /*

      * Entries held in the Cache of known ObjectStreamClass_1_3_1 objects.

      * Entries are chained together with the same hash value (modulo array size).

      */

     private static class ObjectStreamClassEntry // extends java.lang.ref.SoftReference

     {

         ObjectStreamClassEntry(ObjectStreamClass_1_3_1 c) {

             //super(c);

             this.c = c;

         }

         ObjectStreamClassEntry next;

         public Object get()

         {

             return c;

         }

         private ObjectStreamClass_1_3_1 c;

     }

     /*

      * Comparator object for Classes and Interfaces

      */

     private static Comparator compareClassByName =

         new CompareClassByName();

     private static class CompareClassByName implements Comparator {

         public int compare(Object o1, Object o2) {

             Class<?> c1 = (Class)o1;

             Class<?> c2 = (Class)o2;

             return (c1.getName()).compareTo(c2.getName());

         }

     }

     /*

      * Comparator object for Members, Fields, and Methods

      */

     private static Comparator compareMemberByName =

         new CompareMemberByName();

     private static class CompareMemberByName implements Comparator {

         public int compare(Object o1, Object o2) {

             String s1 = ((Member)o1).getName();

             String s2 = ((Member)o2).getName();

             if (o1 instanceof Method) {

                 s1 += getSignature((Method)o1);

                 s2 += getSignature((Method)o2);

             } else if (o1 instanceof Constructor) {

                 s1 += getSignature((Constructor)o1);

                 s2 += getSignature((Constructor)o2);

             }

             return s1.compareTo(s2);

         }

     }

     /* It is expensive to recompute a method or constructor signature

        many times, so compute it only once using this data structure. */

     private static class MethodSignature implements Comparator {

         Member member;

         String signature;      // cached parameter signature

         /* Given an array of Method or Constructor members,

            return a sorted array of the non-private members.*/

         /* A better implementation would be to implement the returned data

            structure as an insertion sorted link list.*/

         static MethodSignature[] removePrivateAndSort(Member[] m) {

             int numNonPrivate = 0;

             for (int i = 0; i < m.length; i++) {

                 if (! Modifier.isPrivate(m[i].getModifiers())) {

                     numNonPrivate++;

                 }

             }

             MethodSignature[] cm = new MethodSignature[numNonPrivate];

             int cmi = 0;

             for (int i = 0; i < m.length; i++) {

                 if (! Modifier.isPrivate(m[i].getModifiers())) {

                     cm[cmi] = new MethodSignature(m[i]);

                     cmi++;

                 }

             }

             if (cmi > 0)

                 Arrays.sort(cm, cm[0]);

             return cm;

         }

         /* Assumes that o1 and o2 are either both methods

            or both constructors.*/

         public int compare(Object o1, Object o2) {

             /* Arrays.sort calls compare when o1 and o2 are equal.*/

             if (o1 == o2)

                 return 0;

             MethodSignature c1 = (MethodSignature)o1;

             MethodSignature c2 = (MethodSignature)o2;

             int result;

             if (isConstructor()) {

                 result = c1.signature.compareTo(c2.signature);

             } else { // is a Method.

                 result = c1.member.getName().compareTo(c2.member.getName());

                 if (result == 0)

                     result = c1.signature.compareTo(c2.signature);

             }

             return result;

         }

         final private boolean isConstructor() {

             return member instanceof Constructor;

         }

         private MethodSignature(Member m) {

             member = m;

             if (isConstructor()) {

                 signature = ObjectStreamClass_1_3_1.getSignature((Constructor)m);

             } else {

                 signature = ObjectStreamClass_1_3_1.getSignature((Method)m);

             }

         }

     }

 }