mirror of
https://github.com/2006-Scape/Parabot.git
synced 2026-07-03 00:37:55 +00:00
Moved to Maven
This commit is contained in:
JKetelaar
@@ -0,0 +1,533 @@
|
||||
/***
|
||||
* ASM: a very small and fast Java bytecode manipulation framework
|
||||
* Copyright (c) 2000-2011 INRIA, France Telecom
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of the copyright holders nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
||||
* THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
package org.objectweb.asm.commons;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.DataOutput;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.security.MessageDigest;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
|
||||
import org.objectweb.asm.ClassVisitor;
|
||||
import org.objectweb.asm.FieldVisitor;
|
||||
import org.objectweb.asm.MethodVisitor;
|
||||
import org.objectweb.asm.Opcodes;
|
||||
|
||||
/**
|
||||
* A {@link ClassVisitor} that adds a serial version unique identifier to a
|
||||
* class if missing. Here is typical usage of this class:
|
||||
*
|
||||
* <pre>
|
||||
* ClassWriter cw = new ClassWriter(...);
|
||||
* ClassVisitor sv = new SerialVersionUIDAdder(cw);
|
||||
* ClassVisitor ca = new MyClassAdapter(sv);
|
||||
* new ClassReader(orginalClass).accept(ca, false);
|
||||
* </pre>
|
||||
*
|
||||
* The SVUID algorithm can be found <a href=
|
||||
* "http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html"
|
||||
* >http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html</a>:
|
||||
*
|
||||
* <pre>
|
||||
* The serialVersionUID is computed using the signature of a stream of bytes
|
||||
* that reflect the class definition. The National Institute of Standards and
|
||||
* Technology (NIST) Secure Hash Algorithm (SHA-1) is used to compute a
|
||||
* signature for the stream. The first two 32-bit quantities are used to form a
|
||||
* 64-bit hash. A java.lang.DataOutputStream is used to convert primitive data
|
||||
* types to a sequence of bytes. The values input to the stream are defined by
|
||||
* the Java Virtual Machine (VM) specification for classes.
|
||||
*
|
||||
* The sequence of items in the stream is as follows:
|
||||
*
|
||||
* 1. The class name written using UTF encoding.
|
||||
* 2. The class modifiers written as a 32-bit integer.
|
||||
* 3. The name of each interface sorted by name written using UTF encoding.
|
||||
* 4. For each field of the class sorted by field name (except private static
|
||||
* and private transient fields):
|
||||
* 1. The name of the field in UTF encoding.
|
||||
* 2. The modifiers of the field written as a 32-bit integer.
|
||||
* 3. The descriptor of the field in UTF encoding
|
||||
* 5. If a class initializer exists, write out the following:
|
||||
* 1. The name of the method, <clinit>, in UTF encoding.
|
||||
* 2. The modifier of the method, java.lang.reflect.Modifier.STATIC,
|
||||
* written as a 32-bit integer.
|
||||
* 3. The descriptor of the method, ()V, in UTF encoding.
|
||||
* 6. For each non-private constructor sorted by method name and signature:
|
||||
* 1. The name of the method, <init>, in UTF encoding.
|
||||
* 2. The modifiers of the method written as a 32-bit integer.
|
||||
* 3. The descriptor of the method in UTF encoding.
|
||||
* 7. For each non-private method sorted by method name and signature:
|
||||
* 1. The name of the method in UTF encoding.
|
||||
* 2. The modifiers of the method written as a 32-bit integer.
|
||||
* 3. The descriptor of the method in UTF encoding.
|
||||
* 8. The SHA-1 algorithm is executed on the stream of bytes produced by
|
||||
* DataOutputStream and produces five 32-bit values sha[0..4].
|
||||
*
|
||||
* 9. The hash value is assembled from the first and second 32-bit values of
|
||||
* the SHA-1 message digest. If the result of the message digest, the five
|
||||
* 32-bit words H0 H1 H2 H3 H4, is in an array of five int values named
|
||||
* sha, the hash value would be computed as follows:
|
||||
*
|
||||
* long hash = ((sha[0] >>> 24) & 0xFF) |
|
||||
* ((sha[0] >>> 16) & 0xFF) << 8 |
|
||||
* ((sha[0] >>> 8) & 0xFF) << 16 |
|
||||
* ((sha[0] >>> 0) & 0xFF) << 24 |
|
||||
* ((sha[1] >>> 24) & 0xFF) << 32 |
|
||||
* ((sha[1] >>> 16) & 0xFF) << 40 |
|
||||
* ((sha[1] >>> 8) & 0xFF) << 48 |
|
||||
* ((sha[1] >>> 0) & 0xFF) << 56;
|
||||
* </pre>
|
||||
*
|
||||
* @author Rajendra Inamdar, Vishal Vishnoi
|
||||
*/
|
||||
public class SerialVersionUIDAdder extends ClassVisitor {
|
||||
|
||||
/**
|
||||
* Flag that indicates if we need to compute SVUID.
|
||||
*/
|
||||
private boolean computeSVUID;
|
||||
|
||||
/**
|
||||
* Set to true if the class already has SVUID.
|
||||
*/
|
||||
private boolean hasSVUID;
|
||||
|
||||
/**
|
||||
* Classes access flags.
|
||||
*/
|
||||
private int access;
|
||||
|
||||
/**
|
||||
* Internal name of the class
|
||||
*/
|
||||
private String name;
|
||||
|
||||
/**
|
||||
* Interfaces implemented by the class.
|
||||
*/
|
||||
private String[] interfaces;
|
||||
|
||||
/**
|
||||
* Collection of fields. (except private static and private transient
|
||||
* fields)
|
||||
*/
|
||||
private Collection<Item> svuidFields;
|
||||
|
||||
/**
|
||||
* Set to true if the class has static initializer.
|
||||
*/
|
||||
private boolean hasStaticInitializer;
|
||||
|
||||
/**
|
||||
* Collection of non-private constructors.
|
||||
*/
|
||||
private Collection<Item> svuidConstructors;
|
||||
|
||||
/**
|
||||
* Collection of non-private methods.
|
||||
*/
|
||||
private Collection<Item> svuidMethods;
|
||||
|
||||
/**
|
||||
* Creates a new {@link SerialVersionUIDAdder}. <i>Subclasses must not use
|
||||
* this constructor</i>. Instead, they must use the
|
||||
* {@link #SerialVersionUIDAdder(int, ClassVisitor)} version.
|
||||
*
|
||||
* @param cv
|
||||
* a {@link ClassVisitor} to which this visitor will delegate
|
||||
* calls.
|
||||
*/
|
||||
public SerialVersionUIDAdder(final ClassVisitor cv) {
|
||||
this(Opcodes.ASM4, cv);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new {@link SerialVersionUIDAdder}.
|
||||
*
|
||||
* @param api
|
||||
* the ASM API version implemented by this visitor. Must be one
|
||||
* of {@link Opcodes#ASM4}.
|
||||
* @param cv
|
||||
* a {@link ClassVisitor} to which this visitor will delegate
|
||||
* calls.
|
||||
*/
|
||||
protected SerialVersionUIDAdder(final int api, final ClassVisitor cv) {
|
||||
super(api, cv);
|
||||
svuidFields = new ArrayList<Item>();
|
||||
svuidConstructors = new ArrayList<Item>();
|
||||
svuidMethods = new ArrayList<Item>();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Overriden methods
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
* Visit class header and get class name, access , and interfaces
|
||||
* information (step 1,2, and 3) for SVUID computation.
|
||||
*/
|
||||
@Override
|
||||
public void visit(final int version, final int access, final String name,
|
||||
final String signature, final String superName,
|
||||
final String[] interfaces) {
|
||||
computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0;
|
||||
|
||||
if (computeSVUID) {
|
||||
this.name = name;
|
||||
this.access = access;
|
||||
this.interfaces = interfaces;
|
||||
}
|
||||
|
||||
super.visit(version, access, name, signature, superName, interfaces);
|
||||
}
|
||||
|
||||
/*
|
||||
* Visit the methods and get constructor and method information (step 5 and
|
||||
* 7). Also determine if there is a class initializer (step 6).
|
||||
*/
|
||||
@Override
|
||||
public MethodVisitor visitMethod(final int access, final String name,
|
||||
final String desc, final String signature, final String[] exceptions) {
|
||||
if (computeSVUID) {
|
||||
if ("<clinit>".equals(name)) {
|
||||
hasStaticInitializer = true;
|
||||
}
|
||||
/*
|
||||
* Remembers non private constructors and methods for SVUID
|
||||
* computation For constructor and method modifiers, only the
|
||||
* ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
|
||||
* ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and ACC_STRICT flags
|
||||
* are used.
|
||||
*/
|
||||
int mods = access
|
||||
& (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
|
||||
| Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
|
||||
| Opcodes.ACC_FINAL | Opcodes.ACC_SYNCHRONIZED
|
||||
| Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_STRICT);
|
||||
|
||||
// all non private methods
|
||||
if ((access & Opcodes.ACC_PRIVATE) == 0) {
|
||||
if ("<init>".equals(name)) {
|
||||
svuidConstructors.add(new Item(name, mods, desc));
|
||||
} else if (!"<clinit>".equals(name)) {
|
||||
svuidMethods.add(new Item(name, mods, desc));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return super.visitMethod(access, name, desc, signature, exceptions);
|
||||
}
|
||||
|
||||
/*
|
||||
* Gets class field information for step 4 of the algorithm. Also determines
|
||||
* if the class already has a SVUID.
|
||||
*/
|
||||
@Override
|
||||
public FieldVisitor visitField(final int access, final String name,
|
||||
final String desc, final String signature, final Object value) {
|
||||
if (computeSVUID) {
|
||||
if ("serialVersionUID".equals(name)) {
|
||||
// since the class already has SVUID, we won't be computing it.
|
||||
computeSVUID = false;
|
||||
hasSVUID = true;
|
||||
}
|
||||
/*
|
||||
* Remember field for SVUID computation For field modifiers, only
|
||||
* the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
|
||||
* ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when
|
||||
* computing serialVersionUID values.
|
||||
*/
|
||||
if ((access & Opcodes.ACC_PRIVATE) == 0
|
||||
|| (access & (Opcodes.ACC_STATIC | Opcodes.ACC_TRANSIENT)) == 0) {
|
||||
int mods = access
|
||||
& (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
|
||||
| Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
|
||||
| Opcodes.ACC_FINAL | Opcodes.ACC_VOLATILE | Opcodes.ACC_TRANSIENT);
|
||||
svuidFields.add(new Item(name, mods, desc));
|
||||
}
|
||||
}
|
||||
|
||||
return super.visitField(access, name, desc, signature, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle a bizarre special case. Nested classes (static classes declared
|
||||
* inside another class) that are protected have their access bit set to
|
||||
* public in their class files to deal with some odd reflection situation.
|
||||
* Our SVUID computation must do as the JVM does and ignore access bits in
|
||||
* the class file in favor of the access bits InnerClass attribute.
|
||||
*/
|
||||
@Override
|
||||
public void visitInnerClass(final String aname, final String outerName,
|
||||
final String innerName, final int attr_access) {
|
||||
if ((name != null) && name.equals(aname)) {
|
||||
this.access = attr_access;
|
||||
}
|
||||
super.visitInnerClass(aname, outerName, innerName, attr_access);
|
||||
}
|
||||
|
||||
/*
|
||||
* Add the SVUID if class doesn't have one
|
||||
*/
|
||||
@Override
|
||||
public void visitEnd() {
|
||||
// compute SVUID and add it to the class
|
||||
if (computeSVUID && !hasSVUID) {
|
||||
try {
|
||||
addSVUID(computeSVUID());
|
||||
} catch (Throwable e) {
|
||||
throw new RuntimeException("Error while computing SVUID for "
|
||||
+ name, e);
|
||||
}
|
||||
}
|
||||
|
||||
super.visitEnd();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Utility methods
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Returns true if the class already has a SVUID field. The result of this
|
||||
* method is only valid when visitEnd is or has been called.
|
||||
*
|
||||
* @return true if the class already has a SVUID field.
|
||||
*/
|
||||
public boolean hasSVUID() {
|
||||
return hasSVUID;
|
||||
}
|
||||
|
||||
protected void addSVUID(long svuid) {
|
||||
FieldVisitor fv = super.visitField(Opcodes.ACC_FINAL
|
||||
+ Opcodes.ACC_STATIC, "serialVersionUID", "J", null, new Long(
|
||||
svuid));
|
||||
if (fv != null) {
|
||||
fv.visitEnd();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Computes and returns the value of SVUID.
|
||||
*
|
||||
* @return Returns the serial version UID
|
||||
* @throws IOException
|
||||
* if an I/O error occurs
|
||||
*/
|
||||
protected long computeSVUID() throws IOException {
|
||||
ByteArrayOutputStream bos;
|
||||
DataOutputStream dos = null;
|
||||
long svuid = 0;
|
||||
|
||||
try {
|
||||
bos = new ByteArrayOutputStream();
|
||||
dos = new DataOutputStream(bos);
|
||||
|
||||
/*
|
||||
* 1. The class name written using UTF encoding.
|
||||
*/
|
||||
dos.writeUTF(name.replace('/', '.'));
|
||||
|
||||
/*
|
||||
* 2. The class modifiers written as a 32-bit integer.
|
||||
*/
|
||||
dos.writeInt(access
|
||||
& (Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL
|
||||
| Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT));
|
||||
|
||||
/*
|
||||
* 3. The name of each interface sorted by name written using UTF
|
||||
* encoding.
|
||||
*/
|
||||
Arrays.sort(interfaces);
|
||||
for (int i = 0; i < interfaces.length; i++) {
|
||||
dos.writeUTF(interfaces[i].replace('/', '.'));
|
||||
}
|
||||
|
||||
/*
|
||||
* 4. For each field of the class sorted by field name (except
|
||||
* private static and private transient fields):
|
||||
*
|
||||
* 1. The name of the field in UTF encoding. 2. The modifiers of the
|
||||
* field written as a 32-bit integer. 3. The descriptor of the field
|
||||
* in UTF encoding
|
||||
*
|
||||
* Note that field signatures are not dot separated. Method and
|
||||
* constructor signatures are dot separated. Go figure...
|
||||
*/
|
||||
writeItems(svuidFields, dos, false);
|
||||
|
||||
/*
|
||||
* 5. If a class initializer exists, write out the following: 1. The
|
||||
* name of the method, <clinit>, in UTF encoding. 2. The modifier of
|
||||
* the method, java.lang.reflect.Modifier.STATIC, written as a
|
||||
* 32-bit integer. 3. The descriptor of the method, ()V, in UTF
|
||||
* encoding.
|
||||
*/
|
||||
if (hasStaticInitializer) {
|
||||
dos.writeUTF("<clinit>");
|
||||
dos.writeInt(Opcodes.ACC_STATIC);
|
||||
dos.writeUTF("()V");
|
||||
} // if..
|
||||
|
||||
/*
|
||||
* 6. For each non-private constructor sorted by method name and
|
||||
* signature: 1. The name of the method, <init>, in UTF encoding. 2.
|
||||
* The modifiers of the method written as a 32-bit integer. 3. The
|
||||
* descriptor of the method in UTF encoding.
|
||||
*/
|
||||
writeItems(svuidConstructors, dos, true);
|
||||
|
||||
/*
|
||||
* 7. For each non-private method sorted by method name and
|
||||
* signature: 1. The name of the method in UTF encoding. 2. The
|
||||
* modifiers of the method written as a 32-bit integer. 3. The
|
||||
* descriptor of the method in UTF encoding.
|
||||
*/
|
||||
writeItems(svuidMethods, dos, true);
|
||||
|
||||
dos.flush();
|
||||
|
||||
/*
|
||||
* 8. The SHA-1 algorithm is executed on the stream of bytes
|
||||
* produced by DataOutputStream and produces five 32-bit values
|
||||
* sha[0..4].
|
||||
*/
|
||||
byte[] hashBytes = computeSHAdigest(bos.toByteArray());
|
||||
|
||||
/*
|
||||
* 9. The hash value is assembled from the first and second 32-bit
|
||||
* values of the SHA-1 message digest. If the result of the message
|
||||
* digest, the five 32-bit words H0 H1 H2 H3 H4, is in an array of
|
||||
* five int values named sha, the hash value would be computed as
|
||||
* follows:
|
||||
*
|
||||
* long hash = ((sha[0] >>> 24) & 0xFF) | ((sha[0] >>> 16) & 0xFF)
|
||||
* << 8 | ((sha[0] >>> 8) & 0xFF) << 16 | ((sha[0] >>> 0) & 0xFF) <<
|
||||
* 24 | ((sha[1] >>> 24) & 0xFF) << 32 | ((sha[1] >>> 16) & 0xFF) <<
|
||||
* 40 | ((sha[1] >>> 8) & 0xFF) << 48 | ((sha[1] >>> 0) & 0xFF) <<
|
||||
* 56;
|
||||
*/
|
||||
for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
|
||||
svuid = (svuid << 8) | (hashBytes[i] & 0xFF);
|
||||
}
|
||||
} finally {
|
||||
// close the stream (if open)
|
||||
if (dos != null) {
|
||||
dos.close();
|
||||
}
|
||||
}
|
||||
|
||||
return svuid;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the SHA-1 message digest of the given value.
|
||||
*
|
||||
* @param value
|
||||
* the value whose SHA message digest must be computed.
|
||||
* @return the SHA-1 message digest of the given value.
|
||||
*/
|
||||
protected byte[] computeSHAdigest(final byte[] value) {
|
||||
try {
|
||||
return MessageDigest.getInstance("SHA").digest(value);
|
||||
} catch (Exception e) {
|
||||
throw new UnsupportedOperationException(e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sorts the items in the collection and writes it to the data output stream
|
||||
*
|
||||
* @param itemCollection
|
||||
* collection of items
|
||||
* @param dos
|
||||
* a <code>DataOutputStream</code> value
|
||||
* @param dotted
|
||||
* a <code>boolean</code> value
|
||||
* @exception IOException
|
||||
* if an error occurs
|
||||
*/
|
||||
private static void writeItems(final Collection<Item> itemCollection,
|
||||
final DataOutput dos, final boolean dotted) throws IOException {
|
||||
int size = itemCollection.size();
|
||||
Item[] items = itemCollection.toArray(new Item[size]);
|
||||
Arrays.sort(items);
|
||||
for (int i = 0; i < size; i++) {
|
||||
dos.writeUTF(items[i].name);
|
||||
dos.writeInt(items[i].access);
|
||||
dos.writeUTF(dotted ? items[i].desc.replace('/', '.')
|
||||
: items[i].desc);
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Inner classes
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
private static class Item implements Comparable<Item> {
|
||||
|
||||
final String name;
|
||||
|
||||
final int access;
|
||||
|
||||
final String desc;
|
||||
|
||||
Item(final String name, final int access, final String desc) {
|
||||
this.name = name;
|
||||
this.access = access;
|
||||
this.desc = desc;
|
||||
}
|
||||
|
||||
public int compareTo(final Item other) {
|
||||
int retVal = name.compareTo(other.name);
|
||||
if (retVal == 0) {
|
||||
retVal = desc.compareTo(other.desc);
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (o instanceof Item) {
|
||||
return compareTo((Item) o) == 0;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return (name + desc).hashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user