libjava/classpath/java/io/ObjectStreamClass.java

   1 /* ObjectStreamClass.java -- Class used to write class information
   2    about serialized objects.
   3    Copyright (C) 1998, 1999, 2000, 2001, 2003, 2005  Free Software Foundation, Inc.
   4
   5 This file is part of GNU Classpath.
   6
   7 GNU Classpath is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Classpath is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Classpath; see the file COPYING.  If not, write to the
  19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301 USA.
  21
  22 Linking this library statically or dynamically with other modules is
  23 making a combined work based on this library.  Thus, the terms and
  24 conditions of the GNU General Public License cover the whole
  25 combination.
  26
  27 As a special exception, the copyright holders of this library give you
  28 permission to link this library with independent modules to produce an
  29 executable, regardless of the license terms of these independent
  30 modules, and to copy and distribute the resulting executable under
  31 terms of your choice, provided that you also meet, for each linked
  32 independent module, the terms and conditions of the license of that
  33 module.  An independent module is a module which is not derived from
  34 or based on this library.  If you modify this library, you may extend
  35 this exception to your version of the library, but you are not
  36 obligated to do so.  If you do not wish to do so, delete this
  37 exception statement from your version. */
  38
  39
  40 package java.io;
  41
  42 import gnu.java.io.NullOutputStream;
  43 import gnu.java.lang.reflect.TypeSignature;
  44 import gnu.java.security.action.SetAccessibleAction;
  45 import gnu.java.security.provider.Gnu;
  46
  47 import java.lang.reflect.Constructor;
  48 import java.lang.reflect.Field;
  49 import java.lang.reflect.Member;
  50 import java.lang.reflect.Method;
  51 import java.lang.reflect.Modifier;
  52 import java.lang.reflect.Proxy;
  53 import java.security.AccessController;
  54 import java.security.DigestOutputStream;
  55 import java.security.MessageDigest;
  56 import java.security.NoSuchAlgorithmException;
  57 import java.security.PrivilegedAction;
  58 import java.security.Security;
  59 import java.util.Arrays;
  60 import java.util.Comparator;
  61 import java.util.Hashtable;
  62
  63 /**
  64  * @author Tom Tromey (tromey@redhat.com)
  65  * @author Jeroen Frijters (jeroen@frijters.net)
  66  * @author Guilhem Lavaux (guilhem@kaffe.org)
  67  * @author Michael Koch (konqueror@gmx.de)
  68  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  69  */
  70 public class ObjectStreamClass implements Serializable
  71 {
  72   static final ObjectStreamField[] INVALID_FIELDS = new ObjectStreamField[0];
  73
  74   /**
  75    * Returns the <code>ObjectStreamClass</code> for <code>cl</code>.
  76    * If <code>cl</code> is null, or is not <code>Serializable</code>,
  77    * null is returned.  <code>ObjectStreamClass</code>'s are memorized;
  78    * later calls to this method with the same class will return the
  79    * same <code>ObjectStreamClass</code> object and no recalculation
  80    * will be done.
  81    *
  82    * Warning: If this class contains an invalid serialPersistentField arrays
  83    * lookup will not throw anything. However {@link #getFields()} will return
  84    * an empty array and {@link java.io.ObjectOutputStream#writeObject} will throw an
  85    * {@link java.io.InvalidClassException}.
  86    *
  87    * @see java.io.Serializable
  88    */
  89   public static ObjectStreamClass lookup(Class<?> cl)
  90   {
  91     if (cl == null)
  92       return null;
  93     if (! (Serializable.class).isAssignableFrom(cl))
  94       return null;
  95
  96     return lookupForClassObject(cl);
  97   }
  98
  99   /**
 100    * This lookup for internal use by ObjectOutputStream.  Suppose
 101    * we have a java.lang.Class object C for class A, though A is not
 102    * serializable, but it's okay to serialize C.
 103    */
 104   static ObjectStreamClass lookupForClassObject(Class cl)
 105   {
 106     if (cl == null)
 107       return null;
 108
 109     ObjectStreamClass osc = (ObjectStreamClass) classLookupTable.get(cl);
 110
 111     if (osc != null)
 112       return osc;
 113     else
 114       {
 115         osc = new ObjectStreamClass(cl);
 116         classLookupTable.put(cl, osc);
 117         return osc;
 118       }
 119   }
 120
 121   /**
 122    * Returns the name of the class that this
 123    * <code>ObjectStreamClass</code> represents.
 124    *
 125    * @return the name of the class.
 126    */
 127   public String getName()
 128   {
 129     return name;
 130   }
 131
 132   /**
 133    * Returns the class that this <code>ObjectStreamClass</code>
 134    * represents.  Null could be returned if this
 135    * <code>ObjectStreamClass</code> was read from an
 136    * <code>ObjectInputStream</code> and the class it represents cannot
 137    * be found or loaded.
 138    *
 139    * @see java.io.ObjectInputStream
 140    */
 141   public Class<?> forClass()
 142   {
 143     return clazz;
 144   }
 145
 146   /**
 147    * Returns the serial version stream-unique identifier for the class
 148    * represented by this <code>ObjectStreamClass</code>.  This SUID is
 149    * either defined by the class as <code>static final long
 150    * serialVersionUID</code> or is calculated as specified in
 151    * Javasoft's "Object Serialization Specification" XXX: add reference
 152    *
 153    * @return the serial version UID.
 154    */
 155   public long getSerialVersionUID()
 156   {
 157     return uid;
 158   }
 159
 160   /**
 161    * Returns the serializable (non-static and non-transient) Fields
 162    * of the class represented by this ObjectStreamClass.  The Fields
 163    * are sorted by name.
 164    * If fields were obtained using serialPersistentFields and this array
 165    * is faulty then the returned array of this method will be empty.
 166    *
 167    * @return the fields.
 168    */
 169   public ObjectStreamField[] getFields()
 170   {
 171     ObjectStreamField[] copy = new ObjectStreamField[ fields.length ];
 172     System.arraycopy(fields, 0, copy, 0, fields.length);
 173     return copy;
 174   }
 175
 176   // XXX doc
 177   // Can't do binary search since fields is sorted by name and
 178   // primitiveness.
 179   public ObjectStreamField getField (String name)
 180   {
 181     for (int i = 0; i < fields.length; i++)
 182       if (fields[i].getName().equals(name))
 183         return fields[i];
 184     return null;
 185   }
 186
 187   /**
 188    * Returns a textual representation of this
 189    * <code>ObjectStreamClass</code> object including the name of the
 190    * class it represents as well as that class's serial version
 191    * stream-unique identifier.
 192    *
 193    * @see #getSerialVersionUID()
 194    * @see #getName()
 195    */
 196   public String toString()
 197   {
 198     return "java.io.ObjectStreamClass< " + name + ", " + uid + " >";
 199   }
 200
 201   // Returns true iff the class that this ObjectStreamClass represents
 202   // has the following method:
 203   //
 204   // private void writeObject (ObjectOutputStream)
 205   //
 206   // This method is used by the class to override default
 207   // serialization behavior.
 208   boolean hasWriteMethod()
 209   {
 210     return (flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0;
 211   }
 212
 213   // Returns true iff the class that this ObjectStreamClass represents
 214   // implements Serializable but does *not* implement Externalizable.
 215   boolean isSerializable()
 216   {
 217     return (flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0;
 218   }
 219
 220
 221   // Returns true iff the class that this ObjectStreamClass represents
 222   // implements Externalizable.
 223   boolean isExternalizable()
 224   {
 225     return (flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0;
 226   }
 227
 228   // Returns true iff the class that this ObjectStreamClass represents
 229   // implements Externalizable.
 230   boolean isEnum()
 231   {
 232     return (flags & ObjectStreamConstants.SC_ENUM) != 0;
 233   }
 234
 235   // Returns the <code>ObjectStreamClass</code> that represents the
 236   // class that is the superclass of the class this
 237   // <code>ObjectStreamClass</code> represents.  If the superclass is
 238   // not Serializable, null is returned.
 239   ObjectStreamClass getSuper()
 240   {
 241     return superClass;
 242   }
 243
 244   /**
 245    * returns an array of ObjectStreamClasses that represent the super
 246    * classes of the class represented by this and the class
 247    * represented by this itself in order from most super to this.
 248    * ObjectStreamClass[0] is the highest superclass of this that is
 249    * serializable.
 250    *
 251    * The result of consecutive calls this hierarchy() will be the same
 252    * array instance.
 253    *
 254    * @return an array of ObjectStreamClass representing the
 255    * super-class hierarchy of serializable classes.
 256    */
 257   ObjectStreamClass[] hierarchy()
 258   {
 259     ObjectStreamClass[] result = hierarchy;
 260     if (result == null)
 261         {
 262         int d = 0;
 263
 264         for(ObjectStreamClass osc = this; osc != null; osc = osc.getSuper())
 265           d++;
 266
 267         result = new ObjectStreamClass[d];
 268
 269         for (ObjectStreamClass osc = this; osc != null; osc = osc.getSuper())
 270           {
 271             result[--d] = osc;
 272           }
 273
 274         hierarchy = result;
 275       }
 276     return result;
 277   }
 278
 279   /**
 280    * Cache for hierarchy() result.
 281    */
 282   private ObjectStreamClass[] hierarchy = null;
 283
 284   // Returns an integer that consists of bit-flags that indicate
 285   // properties of the class represented by this ObjectStreamClass.
 286   // The bit-flags that could be present are those defined in
 287   // ObjectStreamConstants that begin with `SC_'
 288   int getFlags()
 289   {
 290     return flags;
 291   }
 292
 293
 294   ObjectStreamClass(String name, long uid, byte flags,
 295                     ObjectStreamField[] fields)
 296   {
 297     this.name = name;
 298     this.uid = uid;
 299     this.flags = flags;
 300     this.fields = fields;
 301   }
 302
 303   /**
 304    * This method builds the internal description corresponding to a Java Class.
 305    * As the constructor only assign a name to the current ObjectStreamClass instance,
 306    * that method sets the serial UID, chose the fields which will be serialized,
 307    * and compute the position of the fields in the serialized stream.
 308    *
 309    * @param cl The Java class which is used as a reference for building the descriptor.
 310    * @param superClass The descriptor of the super class for this class descriptor.
 311    * @throws InvalidClassException if an incompatibility between computed UID and
 312    * already set UID is found.
 313    */
 314   void setClass(Class cl, ObjectStreamClass superClass) throws InvalidClassException
 315   {hierarchy = null;
 316     this.clazz = cl;
 317
 318     cacheMethods();
 319
 320     long class_uid = getClassUID(cl);
 321     if (uid == 0)
 322       uid = class_uid;
 323     else
 324       {
 325         // Check that the actual UID of the resolved class matches the UID from
 326         // the stream. Mismatches for array classes are ignored.
 327         if (!cl.isArray() && uid != class_uid)
 328           {
 329             String msg = cl +
 330               ": Local class not compatible: stream serialVersionUID="
 331               + uid + ", local serialVersionUID=" + class_uid;
 332             throw new InvalidClassException (msg);
 333           }
 334       }
 335
 336     isProxyClass = clazz != null && Proxy.isProxyClass(clazz);
 337     this.superClass = superClass;
 338     calculateOffsets();
 339
 340     try
 341       {
 342         ObjectStreamField[] exportedFields = getSerialPersistentFields (clazz);
 343
 344         if (exportedFields == null)
 345           return;
 346
 347         ObjectStreamField[] newFieldList = new ObjectStreamField[exportedFields.length + fields.length];
 348         int i, j, k;
 349
 350         /* We now check the import fields against the exported fields.
 351          * There should not be contradiction (e.g. int x and String x)
 352          * but extra virtual fields can be added to the class.
 353          */
 354
 355         Arrays.sort(exportedFields);
 356
 357         i = 0; j = 0; k = 0;
 358         while (i < fields.length && j < exportedFields.length)
 359           {
 360             int comp = fields[i].compareTo(exportedFields[j]);
 361
 362             if (comp < 0)
 363               {
 364                 newFieldList[k] = fields[i];
 365                 fields[i].setPersistent(false);
 366                 fields[i].setToSet(false);
 367                 i++;
 368               }
 369             else if (comp > 0)
 370               {
 371                 /* field not found in imported fields. We add it
 372                  * in the list of supported fields.
 373                  */
 374                 newFieldList[k] = exportedFields[j];
 375                 newFieldList[k].setPersistent(true);
 376                 newFieldList[k].setToSet(false);
 377                 try
 378                   {
 379                     newFieldList[k].lookupField(clazz);
 380                     newFieldList[k].checkFieldType();
 381                   }
 382                 catch (NoSuchFieldException _)
 383                   {
 384                   }
 385                 j++;
 386               }
 387             else
 388               {
 389                 try
 390                   {
 391                     exportedFields[j].lookupField(clazz);
 392                     exportedFields[j].checkFieldType();
 393                   }
 394                 catch (NoSuchFieldException _)
 395                   {
 396                   }
 397
 398                 if (!fields[i].getType().equals(exportedFields[j].getType()))
 399                   throw new InvalidClassException
 400                     ("serialPersistentFields must be compatible with" +
 401                      " imported fields (about " + fields[i].getName() + ")");
 402                 newFieldList[k] = fields[i];
 403                 fields[i].setPersistent(true);
 404                 i++;
 405                 j++;
 406               }
 407             k++;
 408           }
 409
 410         if (i < fields.length)
 411           for (;i<fields.length;i++,k++)
 412             {
 413               fields[i].setPersistent(false);
 414               fields[i].setToSet(false);
 415               newFieldList[k] = fields[i];
 416             }
 417         else
 418           if (j < exportedFields.length)
 419             for (;j<exportedFields.length;j++,k++)
 420               {
 421                 exportedFields[j].setPersistent(true);
 422                 exportedFields[j].setToSet(false);
 423                 newFieldList[k] = exportedFields[j];
 424               }
 425
 426         fields = new ObjectStreamField[k];
 427         System.arraycopy(newFieldList, 0, fields, 0, k);
 428       }
 429     catch (NoSuchFieldException ignore)
 430       {
 431         return;
 432       }
 433     catch (IllegalAccessException ignore)
 434       {
 435         return;
 436       }
 437   }
 438
 439   void setSuperclass (ObjectStreamClass osc)
 440   {
 441     superClass = osc;
 442     hierarchy = null;
 443   }
 444
 445   void calculateOffsets()
 446   {
 447     int i;
 448     ObjectStreamField field;
 449     primFieldSize = 0;
 450     int fcount = fields.length;
 451     for (i = 0; i < fcount; ++ i)
 452       {
 453         field = fields[i];
 454
 455         if (! field.isPrimitive())
 456           break;
 457
 458         field.setOffset(primFieldSize);
 459         switch (field.getTypeCode())
 460           {
 461           case 'B':
 462           case 'Z':
 463             ++ primFieldSize;
 464             break;
 465           case 'C':
 466           case 'S':
 467             primFieldSize += 2;
 468             break;
 469           case 'I':
 470           case 'F':
 471             primFieldSize += 4;
 472             break;
 473           case 'D':
 474           case 'J':
 475             primFieldSize += 8;
 476             break;
 477           }
 478       }
 479
 480     for (objectFieldCount = 0; i < fcount; ++ i)
 481       fields[i].setOffset(objectFieldCount++);
 482   }
 483
 484   private Method findMethod(Method[] methods, String name, Class[] params,
 485                             Class returnType, boolean mustBePrivate)
 486   {
 487 outer:
 488     for (int i = 0; i < methods.length; i++)
 489     {
 490         final Method m = methods[i];
 491         int mods = m.getModifiers();
 492         if (Modifier.isStatic(mods)
 493             || (mustBePrivate && !Modifier.isPrivate(mods)))
 494         {
 495             continue;
 496         }
 497
 498         if (m.getName().equals(name)
 499            && m.getReturnType() == returnType)
 500         {
 501             Class[] mp = m.getParameterTypes();
 502             if (mp.length == params.length)
 503             {
 504                 for (int j = 0; j < mp.length; j++)
 505                 {
 506                     if (mp[j] != params[j])
 507                     {
 508                         continue outer;
 509                     }
 510                 }
 511                 AccessController.doPrivileged(new SetAccessibleAction(m));
 512                 return m;
 513             }
 514         }
 515     }
 516     return null;
 517   }
 518
 519   private static boolean inSamePackage(Class c1, Class c2)
 520   {
 521     String name1 = c1.getName();
 522     String name2 = c2.getName();
 523
 524     int id1 = name1.lastIndexOf('.');
 525     int id2 = name2.lastIndexOf('.');
 526
 527     // Handle the default package
 528     if (id1 == -1 || id2 == -1)
 529       return id1 == id2;
 530
 531     String package1 = name1.substring(0, id1);
 532     String package2 = name2.substring(0, id2);
 533
 534     return package1.equals(package2);
 535   }
 536
 537   final static Class[] noArgs = new Class[0];
 538
 539   private static Method findAccessibleMethod(String name, Class from)
 540   {
 541     for (Class c = from; c != null; c = c.getSuperclass())
 542       {
 543         try
 544           {
 545             Method res = c.getDeclaredMethod(name, noArgs);
 546             int mods = res.getModifiers();
 547
 548             if (c == from
 549                 || Modifier.isProtected(mods)
 550                 || Modifier.isPublic(mods)
 551                 || (! Modifier.isPrivate(mods) && inSamePackage(c, from)))
 552               {
 553                 AccessController.doPrivileged(new SetAccessibleAction(res));
 554                 return res;
 555               }
 556           }
 557         catch (NoSuchMethodException e)
 558           {
 559           }
 560       }
 561
 562     return null;
 563   }
 564
 565   /**
 566    * Helper routine to check if a class was loaded by boot or
 567    * application class loader.  Classes for which this is not the case
 568    * should not be cached since caching prevent class file garbage
 569    * collection.
 570    *
 571    * @param cl a class
 572    *
 573    * @return true if cl was loaded by boot or application class loader,
 574    *         false if cl was loaded by a user class loader.
 575    */
 576   private static boolean loadedByBootOrApplicationClassLoader(Class cl)
 577   {
 578     ClassLoader l = cl.getClassLoader();
 579     return
 580       (   l == null                             /* boot loader */       )
 581       || (l == ClassLoader.getSystemClassLoader() /* application loader */);
 582   }
 583
 584   static Hashtable methodCache = new Hashtable();
 585
 586   static final Class[] readObjectSignature  = { ObjectInputStream.class };
 587   static final Class[] writeObjectSignature = { ObjectOutputStream.class };
 588
 589   private void cacheMethods()
 590   {
 591     Class cl = forClass();
 592     Method[] cached = (Method[]) methodCache.get(cl);
 593     if (cached == null)
 594       {
 595         cached = new Method[4];
 596         Method[] methods = cl.getDeclaredMethods();
 597
 598         cached[0] = findMethod(methods, "readObject",
 599                                readObjectSignature,
 600                                Void.TYPE, true);
 601         cached[1] = findMethod(methods, "writeObject",
 602                                writeObjectSignature,
 603                                Void.TYPE, true);
 604
 605         // readResolve and writeReplace can be in parent classes, as long as they
 606         // are accessible from this class.
 607         cached[2] = findAccessibleMethod("readResolve", cl);
 608         cached[3] = findAccessibleMethod("writeReplace", cl);
 609
 610         /* put in cache if classes not loaded by user class loader.
 611          * For a user class loader, the cache may otherwise grow
 612          * without limit.
 613          */
 614         if (loadedByBootOrApplicationClassLoader(cl))
 615           methodCache.put(cl,cached);
 616       }
 617     readObjectMethod   = cached[0];
 618     writeObjectMethod  = cached[1];
 619     readResolveMethod  = cached[2];
 620     writeReplaceMethod = cached[3];
 621   }
 622
 623   private ObjectStreamClass(Class cl)
 624   {
 625     uid = 0;
 626     flags = 0;
 627     isProxyClass = Proxy.isProxyClass(cl);
 628
 629     clazz = cl;
 630     cacheMethods();
 631     name = cl.getName();
 632     setFlags(cl);
 633     setFields(cl);
 634     // to those class nonserializable, its uid field is 0
 635     if ( (Serializable.class).isAssignableFrom(cl) && !isProxyClass)
 636       uid = getClassUID(cl);
 637     superClass = lookup(cl.getSuperclass());
 638   }
 639
 640
 641   // Sets bits in flags according to features of CL.
 642   private void setFlags(Class cl)
 643   {
 644     if ((java.io.Externalizable.class).isAssignableFrom(cl))
 645       flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
 646     else if ((java.io.Serializable.class).isAssignableFrom(cl))
 647       // only set this bit if CL is NOT Externalizable
 648       flags |= ObjectStreamConstants.SC_SERIALIZABLE;
 649
 650     if (writeObjectMethod != null)
 651       flags |= ObjectStreamConstants.SC_WRITE_METHOD;
 652
 653     if (cl.isEnum() || cl == Enum.class)
 654       flags |= ObjectStreamConstants.SC_ENUM;
 655   }
 656
 657 /* GCJ LOCAL */
 658   // FIXME: This is a workaround for a fairly obscure bug that happens
 659   // when reading a Proxy and then writing it back out again.  The
 660   // result is that the ObjectStreamClass doesn't have its fields set,
 661   // generating a NullPointerException.  Rather than this kludge we
 662   // should probably fix the real bug, but it would require a fairly
 663   // radical reorganization to do so.
 664   final void ensureFieldsSet(Class cl)
 665   {
 666     if (! fieldsSet)
 667       setFields(cl);
 668   }
 669 /* END GCJ LOCAL */
 670
 671
 672   // Sets fields to be a sorted array of the serializable fields of
 673   // clazz.
 674   private void setFields(Class cl)
 675   {
 676 /* GCJ LOCAL */
 677     fieldsSet = true;
 678 /* END GCJ LOCAL */
 679
 680     SetAccessibleAction setAccessible = new SetAccessibleAction();
 681
 682     if (!isSerializable() || isExternalizable() || isEnum())
 683       {
 684         fields = NO_FIELDS;
 685         return;
 686       }
 687
 688     try
 689       {
 690         final Field f =
 691           cl.getDeclaredField("serialPersistentFields");
 692         setAccessible.setMember(f);
 693         AccessController.doPrivileged(setAccessible);
 694         int modifiers = f.getModifiers();
 695
 696         if (Modifier.isStatic(modifiers)
 697             && Modifier.isFinal(modifiers)
 698             && Modifier.isPrivate(modifiers))
 699           {
 700             fields = getSerialPersistentFields(cl);
 701             if (fields != null)
 702               {
 703                 ObjectStreamField[] fieldsName = new ObjectStreamField[fields.length];
 704                 System.arraycopy(fields, 0, fieldsName, 0, fields.length);
 705
 706                 Arrays.sort (fieldsName, new Comparator() {
 707                         public int compare(Object o1, Object o2)
 708                         {
 709                           ObjectStreamField f1 = (ObjectStreamField)o1;
 710                           ObjectStreamField f2 = (ObjectStreamField)o2;
 711
 712                           return f1.getName().compareTo(f2.getName());
 713                         }
 714                     });
 715
 716                 for (int i=1; i < fields.length; i++)
 717                   {
 718                     if (fieldsName[i-1].getName().equals(fieldsName[i].getName()))
 719                         {
 720                             fields = INVALID_FIELDS;
 721                             return;
 722                         }
 723                   }
 724
 725                 Arrays.sort (fields);
 726                 // Retrieve field reference.
 727                 for (int i=0; i < fields.length; i++)
 728                   {
 729                     try
 730                       {
 731                         fields[i].lookupField(cl);
 732                       }
 733                     catch (NoSuchFieldException _)
 734                       {
 735                         fields[i].setToSet(false);
 736                       }
 737                   }
 738
 739                 calculateOffsets();
 740                 return;
 741               }
 742           }
 743       }
 744     catch (NoSuchFieldException ignore)
 745       {
 746       }
 747     catch (IllegalAccessException ignore)
 748       {
 749       }
 750
 751     int num_good_fields = 0;
 752     Field[] all_fields = cl.getDeclaredFields();
 753
 754     int modifiers;
 755     // set non-serializable fields to null in all_fields
 756     for (int i = 0; i < all_fields.length; i++)
 757       {
 758         modifiers = all_fields[i].getModifiers();
 759         if (Modifier.isTransient(modifiers)
 760             || Modifier.isStatic(modifiers))
 761           all_fields[i] = null;
 762         else
 763           num_good_fields++;
 764       }
 765
 766     // make a copy of serializable (non-null) fields
 767     fields = new ObjectStreamField[ num_good_fields ];
 768     for (int from = 0, to = 0; from < all_fields.length; from++)
 769       if (all_fields[from] != null)
 770         {
 771           final Field f = all_fields[from];
 772           setAccessible.setMember(f);
 773           AccessController.doPrivileged(setAccessible);
 774           fields[to] = new ObjectStreamField(all_fields[from]);
 775           to++;
 776         }
 777
 778     Arrays.sort(fields);
 779     // Make sure we don't have any duplicate field names
 780     // (Sun JDK 1.4.1. throws an Internal Error as well)
 781     for (int i = 1; i < fields.length; i++)
 782       {
 783         if(fields[i - 1].getName().equals(fields[i].getName()))
 784             throw new InternalError("Duplicate field " +
 785                         fields[i].getName() + " in class " + cl.getName());
 786       }
 787     calculateOffsets();
 788   }
 789
 790   static Hashtable uidCache = new Hashtable();
 791
 792   // Returns the serial version UID defined by class, or if that
 793   // isn't present, calculates value of serial version UID.
 794   private long getClassUID(Class cl)
 795   {
 796     long result = 0;
 797     Long cache = (Long) uidCache.get(cl);
 798     if (cache != null)
 799       result = cache.longValue();
 800     else
 801       {
 802         try
 803           {
 804             result = getClassUIDFromField(cl);
 805           }
 806         catch (NoSuchFieldException ignore)
 807           {
 808             try
 809               {
 810                 result = calculateClassUID(cl);
 811               }
 812             catch (NoSuchAlgorithmException e)
 813               {
 814                 throw new RuntimeException
 815                   ("The SHA algorithm was not found to use in computing the Serial Version UID for class "
 816                    + cl.getName(), e);
 817               }
 818             catch (IOException ioe)
 819               {
 820                 throw new RuntimeException(ioe);
 821               }
 822           }
 823
 824         if (loadedByBootOrApplicationClassLoader(cl))
 825           uidCache.put(cl,new Long(result));
 826       }
 827     return result;
 828   }
 829
 830   /**
 831    * Search for a serialVersionUID field in the given class and read
 832    * its value.
 833    *
 834    * @return the contents of the serialVersionUID field
 835    *
 836    * @throws NoSuchFieldException if such a field does not exist or is
 837    * not static, not final, not of type Long or not accessible.
 838    */
 839   long getClassUIDFromField(Class cl)
 840     throws NoSuchFieldException
 841   {
 842     long result;
 843
 844     try
 845       {
 846         // Use getDeclaredField rather than getField, since serialVersionUID
 847         // may not be public AND we only want the serialVersionUID of this
 848         // class, not a superclass or interface.
 849         final Field suid = cl.getDeclaredField("serialVersionUID");
 850         SetAccessibleAction setAccessible = new SetAccessibleAction(suid);
 851         AccessController.doPrivileged(setAccessible);
 852         int modifiers = suid.getModifiers();
 853
 854         if (Modifier.isStatic(modifiers)
 855             && Modifier.isFinal(modifiers)
 856             && suid.getType() == Long.TYPE)
 857           result = suid.getLong(null);
 858         else
 859           throw new NoSuchFieldException();
 860       }
 861     catch (IllegalAccessException ignore)
 862       {
 863         throw new NoSuchFieldException();
 864       }
 865
 866     return result;
 867   }
 868
 869   /**
 870    * Calculate class serial version UID for a class that does not
 871    * define serialVersionUID:
 872    *
 873    * @param cl a class
 874    *
 875    * @return the calculated serial varsion UID.
 876    *
 877    * @throws NoSuchAlgorithmException if SHA algorithm not found
 878    *
 879    * @throws IOException if writing to the DigestOutputStream causes
 880    * an IOException.
 881    */
 882   long calculateClassUID(Class cl)
 883     throws NoSuchAlgorithmException, IOException
 884   {
 885     long result;
 886     MessageDigest md;
 887     try
 888       {
 889         md = MessageDigest.getInstance("SHA");
 890       }
 891     catch (NoSuchAlgorithmException e)
 892       {
 893         // If a provider already provides SHA, use it; otherwise, use this.
 894         Gnu gnuProvider = new Gnu();
 895         Security.addProvider(gnuProvider);
 896         md = MessageDigest.getInstance("SHA");
 897       }
 898
 899     DigestOutputStream digest_out =
 900       new DigestOutputStream(nullOutputStream, md);
 901     DataOutputStream data_out = new DataOutputStream(digest_out);
 902
 903     data_out.writeUTF(cl.getName());
 904
 905     int modifiers = cl.getModifiers();
 906     // just look at interesting bits
 907     modifiers = modifiers & (Modifier.ABSTRACT | Modifier.FINAL
 908                              | Modifier.INTERFACE | Modifier.PUBLIC);
 909     data_out.writeInt(modifiers);
 910
 911     // Pretend that an array has no interfaces, because when array
 912     // serialization was defined (JDK 1.1), arrays didn't have it.
 913     if (! cl.isArray())
 914       {
 915         Class[] interfaces = cl.getInterfaces();
 916         Arrays.sort(interfaces, interfaceComparator);
 917         for (int i = 0; i < interfaces.length; i++)
 918           data_out.writeUTF(interfaces[i].getName());
 919       }
 920
 921     Field field;
 922     Field[] fields = cl.getDeclaredFields();
 923     Arrays.sort(fields, memberComparator);
 924     for (int i = 0; i < fields.length; i++)
 925       {
 926         field = fields[i];
 927         modifiers = field.getModifiers();
 928         if (Modifier.isPrivate(modifiers)
 929             && (Modifier.isStatic(modifiers)
 930                 || Modifier.isTransient(modifiers)))
 931           continue;
 932
 933         data_out.writeUTF(field.getName());
 934         data_out.writeInt(modifiers);
 935         data_out.writeUTF(TypeSignature.getEncodingOfClass (field.getType()));
 936       }
 937
 938     // write class initializer method if present
 939     if (VMObjectStreamClass.hasClassInitializer(cl))
 940       {
 941         data_out.writeUTF("<clinit>");
 942         data_out.writeInt(Modifier.STATIC);
 943         data_out.writeUTF("()V");
 944       }
 945
 946     Constructor constructor;
 947     Constructor[] constructors = cl.getDeclaredConstructors();
 948     Arrays.sort (constructors, memberComparator);
 949     for (int i = 0; i < constructors.length; i++)
 950       {
 951         constructor = constructors[i];
 952         modifiers = constructor.getModifiers();
 953         if (Modifier.isPrivate(modifiers))
 954           continue;
 955
 956         data_out.writeUTF("<init>");
 957         data_out.writeInt(modifiers);
 958
 959         // the replacement of '/' with '.' was needed to make computed
 960         // SUID's agree with those computed by JDK
 961         data_out.writeUTF
 962           (TypeSignature.getEncodingOfConstructor(constructor).replace('/','.'));
 963       }
 964
 965     Method method;
 966     Method[] methods = cl.getDeclaredMethods();
 967     Arrays.sort(methods, memberComparator);
 968     for (int i = 0; i < methods.length; i++)
 969       {
 970         method = methods[i];
 971         modifiers = method.getModifiers();
 972         if (Modifier.isPrivate(modifiers))
 973           continue;
 974
 975         data_out.writeUTF(method.getName());
 976         data_out.writeInt(modifiers);
 977
 978         // the replacement of '/' with '.' was needed to make computed
 979         // SUID's agree with those computed by JDK
 980         data_out.writeUTF
 981           (TypeSignature.getEncodingOfMethod(method).replace('/', '.'));
 982       }
 983
 984     data_out.close();
 985     byte[] sha = md.digest();
 986     result = 0;
 987     int len = sha.length < 8 ? sha.length : 8;
 988     for (int i = 0; i < len; i++)
 989       result += (long) (sha[i] & 0xFF) << (8 * i);
 990
 991     return result;
 992   }
 993
 994   /**
 995    * Returns the value of CLAZZ's private static final field named
 996    * `serialPersistentFields'. It performs some sanity checks before
 997    * returning the real array. Besides, the returned array is a clean
 998    * copy of the original. So it can be modified.
 999    *
1000    * @param clazz Class to retrieve 'serialPersistentFields' from.
1001    * @return The content of 'serialPersistentFields'.
1002    */
1003   private ObjectStreamField[] getSerialPersistentFields(Class clazz)
1004     throws NoSuchFieldException, IllegalAccessException
1005   {
1006     ObjectStreamField[] fieldsArray = null;
1007     ObjectStreamField[] o;
1008
1009     // Use getDeclaredField rather than getField for the same reason
1010     // as above in getDefinedSUID.
1011     Field f = clazz.getDeclaredField("serialPersistentFields");
1012     f.setAccessible(true);
1013
1014     int modifiers = f.getModifiers();
1015     if (!(Modifier.isStatic(modifiers) &&
1016           Modifier.isFinal(modifiers) &&
1017           Modifier.isPrivate(modifiers)))
1018       return null;
1019
1020     o = (ObjectStreamField[]) f.get(null);
1021
1022     if (o == null)
1023       return null;
1024
1025     fieldsArray = new ObjectStreamField[ o.length ];
1026     System.arraycopy(o, 0, fieldsArray, 0, o.length);
1027
1028     return fieldsArray;
1029   }
1030
1031   /**
1032    * Returns a new instance of the Class this ObjectStreamClass corresponds
1033    * to.
1034    * Note that this should only be used for Externalizable classes.
1035    *
1036    * @return A new instance.
1037    */
1038   Externalizable newInstance() throws InvalidClassException
1039   {
1040     synchronized(this)
1041     {
1042         if (constructor == null)
1043         {
1044             try
1045             {
1046                 final Constructor c = clazz.getConstructor(new Class[0]);
1047
1048                 AccessController.doPrivileged(new PrivilegedAction()
1049                 {
1050                     public Object run()
1051                     {
1052                         c.setAccessible(true);
1053                         return null;
1054                     }
1055                 });
1056
1057                 constructor = c;
1058             }
1059             catch(NoSuchMethodException x)
1060             {
1061                 throw new InvalidClassException(clazz.getName(),
1062                     "No public zero-argument constructor");
1063             }
1064         }
1065     }
1066
1067     try
1068     {
1069         return (Externalizable)constructor.newInstance(null);
1070     }
1071     catch(Exception x)
1072     {
1073         throw (InvalidClassException)
1074             new InvalidClassException(clazz.getName(),
1075                      "Unable to instantiate").initCause(x);
1076     }
1077   }
1078
1079   public static final ObjectStreamField[] NO_FIELDS = {};
1080
1081   private static Hashtable<Class,ObjectStreamClass> classLookupTable
1082     = new Hashtable<Class,ObjectStreamClass>();
1083   private static final NullOutputStream nullOutputStream = new NullOutputStream();
1084   private static final Comparator interfaceComparator = new InterfaceComparator();
1085   private static final Comparator memberComparator = new MemberComparator();
1086   private static final
1087     Class[] writeMethodArgTypes = { java.io.ObjectOutputStream.class };
1088
1089   private ObjectStreamClass superClass;
1090   private Class<?> clazz;
1091   private String name;
1092   private long uid;
1093   private byte flags;
1094
1095   // this field is package protected so that ObjectInputStream and
1096   // ObjectOutputStream can access it directly
1097   ObjectStreamField[] fields;
1098
1099   // these are accessed by ObjectIn/OutputStream
1100   int primFieldSize = -1;  // -1 if not yet calculated
1101   int objectFieldCount;
1102
1103   Method readObjectMethod;
1104   Method readResolveMethod;
1105   Method writeReplaceMethod;
1106   Method writeObjectMethod;
1107   boolean realClassIsSerializable;
1108   boolean realClassIsExternalizable;
1109   ObjectStreamField[] fieldMapping;
1110   Constructor firstNonSerializableParentConstructor;
1111   private Constructor constructor;  // default constructor for Externalizable
1112
1113   boolean isProxyClass = false;
1114
1115 /* GCJ LOCAL */
1116   // True after setFields() has been called
1117   private boolean fieldsSet = false;
1118 /* END GCJ LOCAL */
1119
1120   // This is probably not necessary because this class is special cased already
1121   // but it will avoid showing up as a discrepancy when comparing SUIDs.
1122   private static final long serialVersionUID = -6120832682080437368L;
1123
1124
1125   // interfaces are compared only by name
1126   private static final class InterfaceComparator implements Comparator
1127   {
1128     public int compare(Object o1, Object o2)
1129     {
1130       return ((Class) o1).getName().compareTo(((Class) o2).getName());
1131     }
1132   }
1133
1134
1135   // Members (Methods and Constructors) are compared first by name,
1136   // conflicts are resolved by comparing type signatures
1137   private static final class MemberComparator implements Comparator
1138   {
1139     public int compare(Object o1, Object o2)
1140     {
1141       Member m1 = (Member) o1;
1142       Member m2 = (Member) o2;
1143
1144       int comp = m1.getName().compareTo(m2.getName());
1145
1146       if (comp == 0)
1147         return TypeSignature.getEncodingOfMember(m1).
1148           compareTo(TypeSignature.getEncodingOfMember(m2));
1149       else
1150         return comp;
1151     }
1152   }
1153 }