Example #1
0
 /**
  * Override coverts old class names into new class names to preserve compatibility with
  * pre-Apache namespaces.
  */
 @Override
 protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
   ObjectStreamClass read = super.readClassDescriptor();
   if (read.getName().startsWith("com.fs.pxe.")) {
     return ObjectStreamClass.lookup(
         Class.forName(read.getName().replace("com.fs.pxe.", "org.apache.ode.")));
   }
   if (read.getName().startsWith("com.fs.utils.")) {
     return ObjectStreamClass.lookup(
         Class.forName(read.getName().replace("com.fs.utils.", "org.apache.ode.utils.")));
   }
   return read;
 }
  /**
   * Computes the serial version UID value for the given class. The code is taken from {@link
   * ObjectStreamClass#computeDefaultSUID(Class)}.
   *
   * @param cls A class.
   * @return A serial version UID.
   * @throws IOException If failed.
   */
  static long computeSerialVersionUid(Class cls) throws IOException {
    if (Serializable.class.isAssignableFrom(cls) && !Enum.class.isAssignableFrom(cls)) {
      return ObjectStreamClass.lookup(cls).getSerialVersionUID();
    }

    MessageDigest md;

    try {
      md = MessageDigest.getInstance("SHA");
    } catch (NoSuchAlgorithmException e) {
      throw new IOException("Failed to get digest for SHA.", e);
    }

    md.update(cls.getName().getBytes(UTF_8));

    for (Field f : getFieldsForSerialization(cls)) {
      md.update(f.getName().getBytes(UTF_8));
      md.update(f.getType().getName().getBytes(UTF_8));
    }

    byte[] hashBytes = md.digest();

    long hash = 0;

    // Composes a single-long hash from the byte[] hash.
    for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--)
      hash = (hash << 8) | (hashBytes[i] & 0xFF);

    return hash;
  }
 /*     */ public String[] bases(String paramString) /*     */ {
   /*     */ try
   /*     */ {
     /* 163 */ if (this.vhandler == null) {
       /* 164 */ this.vhandler = ValueHandlerImpl.getInstance(false);
       /*     */ }
     /*     */
     /* 167 */ Stack localStack = new Stack();
     /* 168 */ Class localClass =
         ObjectStreamClass.lookup(this.vhandler.getClassFromType(paramString))
             .forClass()
             .getSuperclass();
     /*     */
     /* 170 */ while (!localClass.equals(Object.class)) {
       /* 171 */ localStack.push(this.vhandler.createForAnyType(localClass));
       /* 172 */ localClass = localClass.getSuperclass();
       /*     */ }
     /*     */
     /* 175 */ String[] arrayOfString = new String[localStack.size()];
     /* 176 */ for (int i = arrayOfString.length - 1; i >= 0; i++) {
       /* 177 */ arrayOfString[i] = ((String) localStack.pop());
       /*     */ }
     /* 179 */ return arrayOfString;
     /*     */ } catch (Throwable localThrowable) {
     /* 181 */ throw this.wrapper.missingLocalValueImpl(
         CompletionStatus.COMPLETED_MAYBE, localThrowable);
     /*     */ }
   /*     */ }
 public static void writeObject(Object obj, SerializationInfo info) {
   try {
     boolean replaced = false;
     Class cl = obj.getClass();
     ObjectStreamClass desc;
     for (; ; ) {
       Class repCl;
       desc = ObjectStreamClass.lookup(cl, true);
       if (!desc.hasWriteReplaceMethod()
           || (obj = desc.invokeWriteReplace(obj)) == null
           || (repCl = obj.getClass()) == cl) {
         break;
       }
       cl = repCl;
       replaced = true;
     }
     if (replaced) {
       info.AddValue("obj", obj);
       info.SetType(ikvm.runtime.Util.getInstanceTypeFromClass(ReplaceProxy.class));
     } else {
       new InteropObjectOutputStream(info, obj, cl, desc);
     }
   } catch (IOException x) {
     ikvm.runtime.Util.throwException(new SerializationException(x.getMessage(), x));
   }
 }
 @Override
 protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
   ObjectStreamClass classDesc = super.readClassDescriptor();
   String className = classDesc.getName();
   return renamedClasses.containsKey(className)
       ? ObjectStreamClass.lookup(renamedClasses.get(className))
       : classDesc;
 }
class TestObjectOutputStream extends ObjectOutputStream {

  static ObjectStreamClass fooDesc = ObjectStreamClass.lookup(Foo.class);
  static ObjectStreamClass integerDesc = ObjectStreamClass.lookup(Integer.class);

  TestObjectOutputStream(OutputStream out) throws IOException {
    super(out);
  }

  protected void writeClassDescriptor(ObjectStreamClass desc) throws IOException {
    if (desc == fooDesc) {
      super.writeClassDescriptor(integerDesc);
    } else if (desc == integerDesc) {
      super.writeClassDescriptor(fooDesc);
    } else {
      super.writeClassDescriptor(desc);
    }
  }
}
Example #7
0
 protected void annotateClass(Class cl) throws IOException {
   super.annotateClass(cl);
   if (verbose) {
     ObjectStreamClass desc = ObjectStreamClass.lookup(cl);
     System.out.println("******************");
     System.out.println("annotateClass(" + cl.getName() + ")");
     System.out.println("******************");
     SerialBox.print(desc);
   }
 }
 /*     */ public FullValueDescription meta(String paramString) /*     */ {
   /*     */ try {
     /* 117 */ FullValueDescription localFullValueDescription =
         (FullValueDescription) fvds.get(paramString);
     /*     */
     /* 119 */ if (localFullValueDescription == null)
     /*     */ {
       /* 122 */ if (this.vhandler == null) {
         /* 123 */ this.vhandler = ValueHandlerImpl.getInstance(false);
         /*     */ }
       /*     */ try
       /*     */ {
         /* 127 */ localFullValueDescription =
             ValueUtility.translate(
                 _orb(),
                 ObjectStreamClass.lookup(this.vhandler.getAnyClassFromType(paramString)),
                 this.vhandler);
         /*     */ }
       /*     */ catch (Throwable localThrowable2) {
         /* 130 */ if (this.orb == null) /* 131 */ this.orb = ORB.init();
         /* 132 */ localFullValueDescription =
             ValueUtility.translate(
                 this.orb,
                 ObjectStreamClass.lookup(this.vhandler.getAnyClassFromType(paramString)),
                 this.vhandler);
         /*     */ }
       /*     */
       /* 136 */ if (localFullValueDescription != null)
         /* 137 */ fvds.put(paramString, localFullValueDescription);
       /*     */ else {
         /* 139 */ throw this.wrapper.missingLocalValueImpl(CompletionStatus.COMPLETED_MAYBE);
         /*     */ }
       /*     */ }
     /*     */
     /* 143 */ return localFullValueDescription;
     /*     */ } catch (Throwable localThrowable1) {
     /* 145 */ throw this.wrapper.incompatibleValueImpl(
         CompletionStatus.COMPLETED_MAYBE, localThrowable1);
     /*     */ }
   /*     */ }
Example #9
0
 protected Class resolveClass(ObjectStreamClass v) throws ClassNotFoundException, IOException {
   if (verbose) {
     System.out.println("*******************************BEGIN");
     System.out.println("**Stream ObjectStreamClass Descriptor");
     SerialBox.print(v);
   }
   Class cl = super.resolveClass(v);
   if (verbose) {
     ObjectStreamClass localDesc = ObjectStreamClass.lookup(cl);
     if (localDesc != null) {
       System.out.println("**Local JVM ObjectStreamClass Descriptor");
       SerialBox.print(localDesc);
     }
     System.out.println("*******************************END ");
   }
   return cl;
 }
Example #10
0
 public static void main(String args[]) throws Exception {
   File f = new File("tmp.ser");
   if (args[0].compareTo("-s") == 0) {
     FileOutputStream of = new FileOutputStream(f);
     ObjectOutputStream oos = new ObjectOutputStream(of);
     Class cl = Class.forName(args[1]);
     oos.writeObject(cl);
     if (ObjectStreamClass.lookup(cl) != null) oos.writeObject(cl.newInstance());
     oos.close();
     System.out.println("Serialized Class " + cl.getName());
   } else if (args[0].compareTo("-de") == 0) {
     FileInputStream inf = new FileInputStream(f);
     ObjectInputStream ois = new ObjectInputStream(inf);
     Class cl = null;
     try {
       cl = (Class) ois.readObject();
       throw new Error("Expected InvalidClassException to be thrown");
     } catch (InvalidClassException e) {
       System.out.println("Caught expected exception DeSerializing class " + e.getMessage());
     }
     ois.close();
   } else if (args[0].compareTo("-doe") == 0) {
     FileInputStream inf = new FileInputStream(f);
     ObjectInputStream ois = new ObjectInputStream(inf);
     Class cl = null;
     cl = (Class) ois.readObject();
     try {
       ois.readObject();
       throw new Error("Expected InvalidClassException to be thrown");
     } catch (InvalidClassException e) {
       System.out.println("Caught expected exception DeSerializing class " + e.getMessage());
     }
     ois.close();
   } else if (args[0].compareTo("-d") == 0) {
     FileInputStream inf = new FileInputStream(f);
     ObjectInputStream ois = new ObjectInputStream(inf);
     Class cl = (Class) ois.readObject();
     try {
       ois.readObject();
     } catch (EOFException e) {
     }
     ois.close();
     System.out.println("DeSerialized Class " + cl.getName());
   }
 }
Example #11
0
  private static Map<String, Long> getMessageSVUID(Type messageType)
      throws SJIOException,
          ClassNotFoundException // SJCompilerUtils has a simpler version of this routine.
      {
    HashMap<String, Long> ours = new HashMap<String, Long>();

    if (messageType
        instanceof
        SJSessionType) // Should come before ordinary class cases? (But SJSessionType shouldn't be a
                       // class type).
    {
      ours.putAll(getClassSVUIDs((SJSessionType) messageType));
    } else if (messageType.isPrimitive()) {
      // No SVUID needed for primitive types.
    } else if (messageType.isClass()) // Duplicated from above.
    {
      String className = messageType.toClass().fullName();
      Class<?> c = Class.forName(className);

      if (c.isInterface()) {
        // Interfaces don't have SVUIDs (so what should we do here?). // This encourages use of
        // abstract classes rather than interfaces for message types?
      } else {
        ObjectStreamClass osc = ObjectStreamClass.lookup(c);

        if (osc == null) {
          throw new SJIOException("Class not serializable: " + c);
        }

        ours.put(
            className,
            osc
                .getSerialVersionUID()); // Not possible to find a different SVUID for the same
                                         // (name) class here? // SVUIDs could be recorded in the
                                         // session type objects. // Put currently problems working
                                         // with these values at compilation time if the class
                                         // binary is not available a priori (SVUID value not built
                                         // yet?).
      }
    } else if (messageType.isArray()) {
      throw new SJIOException("Array types not done yet: " + messageType);
    }

    return ours;
  }
 protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
   hookCalled = true;
   return ObjectStreamClass.lookup(Class.forName(readUTF()));
 }
  /**
   * Deserializes examplars stored in archives in getArchiveDirectory().
   *
   * @throws RuntimeException if clazz cannot be serialized. This exception has an informative
   *     message and wraps the originally thrown exception as root cause.
   * @see #getArchiveDirectory()
   */
  public void deserializeArchivedVersions() throws RuntimeException {
    System.out.println("Deserializing archived instances in " + getArchiveDirectory() + ".");

    File archive = new File(getArchiveDirectory());

    if (!archive.exists() || !archive.isDirectory()) {
      return;
    }

    String[] listing = archive.list();

    for (String archiveName : listing) {
      if (!(archiveName.endsWith(".zip"))) {
        continue;
      }

      try {
        File file = new File(getArchiveDirectory(), archiveName);
        ZipFile zipFile = new ZipFile(file);
        ZipEntry entry = zipFile.getEntry("class_fields.ser");
        InputStream inputStream = zipFile.getInputStream(entry);
        ObjectInputStream objectIn = new ObjectInputStream(inputStream);
        Map<String, List<String>> classFields = (Map<String, List<String>>) objectIn.readObject();
        zipFile.close();

        for (String className : classFields.keySet()) {

          //                    if (classFields.equals("HypotheticalGraph")) continue;

          List<String> fieldNames = classFields.get(className);
          Class<?> clazz = Class.forName(className);
          ObjectStreamClass streamClass = ObjectStreamClass.lookup(clazz);

          if (streamClass == null) {
            System.out.println();
          }

          for (String fieldName : fieldNames) {
            assert streamClass != null;
            ObjectStreamField field = streamClass.getField(fieldName);

            if (field == null) {
              throw new RuntimeException(
                  "Field '"
                      + fieldName
                      + "' was dropped from class '"
                      + className
                      + "' as a serializable field! Please "
                      + "put it back!!!"
                      + "\nIt used to be in "
                      + className
                      + " in this archive: "
                      + archiveName
                      + ".");
            }
          }
        }
      } catch (ClassNotFoundException e) {
        throw new RuntimeException(
            "Could not read class_fields.ser in archive + " + archiveName + " .", e);
      } catch (IOException e) {
        throw new RuntimeException("Problem reading archive" + archiveName + "; see cause.", e);
      }

      System.out.println("...Deserializing instances in " + archiveName + "...");
      ZipEntry zipEntry = null;

      try {
        File file = new File(getArchiveDirectory(), archiveName);
        FileInputStream in = new FileInputStream(file);
        ZipInputStream zipinputstream = new ZipInputStream(in);

        while ((zipEntry = zipinputstream.getNextEntry()) != null) {
          if (!zipEntry.getName().endsWith(".ser")) {
            continue;
          }

          ObjectInputStream objectIn = new ObjectInputStream(zipinputstream);
          objectIn.readObject();
          zipinputstream.closeEntry();
        }

        zipinputstream.close();
      } catch (ClassNotFoundException e) {
        throw new RuntimeException(
            "Could not read object zipped file "
                + zipEntry.getName()
                + " in archive "
                + archiveName
                + ". "
                + "Perhaps the class was renamed, moved to another package, or "
                + "removed. In any case, please put it back where it was.",
            e);
      } catch (IOException e) {
        throw new RuntimeException("Problem reading archive" + archiveName + "; see cause.", e);
      }
    }

    System.out.println("Finished deserializing archived instances.");
  }
  /**
   * Serializes the given class to the getCurrentDirectory() directory. The static
   * serializedInstance() method of clazz will be called to get an examplar of clazz. This examplar
   * will then be serialized out to a file stored in getCurrentDirectory().
   *
   * @param clazz the class to serialize.
   * @throws RuntimeException if clazz cannot be serialized. This exception has an informative
   *     message and wraps the originally thrown exception as root cause.
   * @see #getCurrentDirectory()
   */
  private void serializeClass(Class clazz, Map<String, List<String>> classFields)
      throws RuntimeException {
    File current = new File(getCurrentDirectory());

    if (!current.exists() || !current.isDirectory()) {
      throw new IllegalStateException(
          "There is no "
              + current.getAbsolutePath()
              + " directory. "
              + "\nThis is where the serialized classes should be. "
              + "Please run serializeCurrentDirectory() first.");
    }

    try {
      Field field = clazz.getDeclaredField("serialVersionUID");

      int modifiers = field.getModifiers();
      boolean _static = Modifier.isStatic(modifiers);
      boolean _final = Modifier.isFinal(modifiers);
      field.setAccessible(true);

      if (!_static || !_final || !(23L == field.getLong(null))) {
        throw new RuntimeException(
            "Class " + clazz + " does not define static final " + "long serialVersionUID = 23L");
      }

      int numFields = getNumNonSerialVersionUIDFields(clazz);

      if (numFields > 0) {
        Method method = clazz.getMethod("serializableInstance");
        Object object = method.invoke(null);

        File file = new File(current, clazz.getName() + ".ser");
        boolean created = file.createNewFile();

        FileOutputStream out = new FileOutputStream(file);
        ObjectOutputStream objOut = new ObjectOutputStream(out);
        objOut.writeObject(object);
        out.close();
      }

      // Make entry in list of class fields.
      ObjectStreamClass objectStreamClass = ObjectStreamClass.lookup(clazz);
      String className = objectStreamClass.getName();
      ObjectStreamField[] fields = objectStreamClass.getFields();
      @SuppressWarnings("Convert2Diamond")
      List<String> fieldList = new ArrayList<>();

      for (ObjectStreamField objectStreamField : fields) {
        String fieldName = objectStreamField.getName();
        fieldList.add(fieldName);
      }

      classFields.put(className, fieldList);
    } catch (NoSuchFieldException e) {
      throw new RuntimeException(
          ("There is no static final long field "
              + "'serialVersionUID' in "
              + clazz
              + ". Please make one and set it "
              + "to 23L."));
    } catch (NoSuchMethodException e) {
      throw new RuntimeException(
          "Class " + clazz + "does not " + "have a public static serializableInstance constructor.",
          e);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(
          "The method serializableInstance() of " + "class " + clazz + " is not public.", e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException(
          "Unable to statically call the "
              + "serializableInstance() method of class "
              + clazz
              + ".",
          e);
    } catch (IOException e) {
      throw new RuntimeException(
          "Could not create a new, writeable file "
              + "in "
              + getCurrentDirectory()
              + " when trying to serialize "
              + clazz
              + ".",
          e);
    }
  }