/** serialPersistentFields value indicating no serializable fields */

public static final ObjectStreamField[] NO_FIELDS =

new ObjectStreamField[0];

private static final long serialVersionUID = -6120832682080437368L;

private static final ObjectStreamField[] serialPersistentFields =

NO_FIELDS;

/** true if deserialization constructor checking is disabled */

private static boolean disableSerialConstructorChecks =

AccessController.doPrivileged(

new PrivilegedAction<Boolean>() {

public Boolean run() {

String prop = "jdk.disableSerialConstructorChecks";

return "true".equals(System.getProperty(prop))

? Boolean.TRUE : Boolean.FALSE;

}

}

).booleanValue();

/** reflection factory for obtaining serialization constructors */

private static final ReflectionFactory reflFactory =

AccessController.doPrivileged(

new ReflectionFactory.GetReflectionFactoryAction());

private static class Caches {

/** cache mapping local classes -> descriptors */

static final ConcurrentMap<WeakClassKey,Reference<?>> localDescs =

new ConcurrentHashMap<>();

/** cache mapping field group/local desc pairs -> field reflectors */

static final ConcurrentMap<FieldReflectorKey,Reference<?>> reflectors =

new ConcurrentHashMap<>();

/** queue for WeakReferences to local classes */

private static final ReferenceQueue<Class<?>> localDescsQueue =

new ReferenceQueue<>();

/** queue for WeakReferences to field reflectors keys */

private static final ReferenceQueue<Class<?>> reflectorsQueue =

new ReferenceQueue<>();

}

/** class associated with this descriptor (if any) */

private Class<?> cl;

/** name of class represented by this descriptor */

private String name;

/** serialVersionUID of represented class (null if not computed yet) */

private volatile Long suid;

/** true if represents dynamic proxy class */

private boolean isProxy;

/** true if represents enum type */

private boolean isEnum;

/** true if represented class implements Serializable */

private boolean serializable;

/** true if represented class implements Externalizable */

private boolean externalizable;

/** true if desc has data written by class-defined writeObject method */

private boolean hasWriteObjectData;

/**

private boolean hasBlockExternalData = true;

/**

private static class ExceptionInfo {

private final String className;

private final String message;

ExceptionInfo(String cn, String msg) {

className = cn;

message = msg;

}

/**

InvalidClassException newInvalidClassException() {

return new InvalidClassException(className, message);

}

}

/** exception (if any) thrown while attempting to resolve class */

private ClassNotFoundException resolveEx;

/** exception (if any) to throw if non-enum deserialization attempted */

private ExceptionInfo deserializeEx;

/** exception (if any) to throw if non-enum serialization attempted */

private ExceptionInfo serializeEx;

/** exception (if any) to throw if default serialization attempted */

private ExceptionInfo defaultSerializeEx;

/** serializable fields */

private ObjectStreamField[] fields;

/** aggregate marshalled size of primitive fields */

private int primDataSize;

/** number of non-primitive fields */

private int numObjFields;

/** reflector for setting/getting serializable field values */

private FieldReflector fieldRefl;

/** data layout of serialized objects described by this class desc */

private volatile ClassDataSlot[] dataLayout;

/** serialization-appropriate constructor, or null if none */

private Constructor<?> cons;

/** protection domains that need to be checked when calling the constructor */

private ProtectionDomain[] domains;

/** class-defined writeObject method, or null if none */

private Method writeObjectMethod;

/** class-defined readObject method, or null if none */

private Method readObjectMethod;

/** class-defined readObjectNoData method, or null if none */

private Method readObjectNoDataMethod;

/** class-defined writeReplace method, or null if none */

private Method writeReplaceMethod;

/** class-defined readResolve method, or null if none */

private Method readResolveMethod;

/** local class descriptor for represented class (may point to self) */

private ObjectStreamClass localDesc;

/** superclass descriptor appearing in stream */

private ObjectStreamClass superDesc;

/** true if, and only if, the object has been correctly initialized */

private boolean initialized;

/**

private static native void initNative();

static {

initNative();

}

/**

public static ObjectStreamClass lookup(Class<?> cl) {

return lookup(cl, false);

}

/**

public static ObjectStreamClass lookupAny(Class<?> cl) {

return lookup(cl, true);

}

/**

public String getName() {

return name;

}

/**

public long getSerialVersionUID() {

// REMIND: synchronize instead of relying on volatile?

if (suid == null) {

suid = AccessController.doPrivileged(

new PrivilegedAction<Long>() {

public Long run() {

return computeDefaultSUID(cl);

}

}

);

}

return suid.longValue();

}

/**

@CallerSensitive

public Class<?> forClass() {

if (cl == null) {

return null;

}

requireInitialized();

if (System.getSecurityManager() != null) {

Class<?> caller = Reflection.getCallerClass();

if (ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(), cl.getClassLoader())) {

ReflectUtil.checkPackageAccess(cl);

}

}

return cl;

}

/**

public ObjectStreamField[] getFields() {

return getFields(true);

}

/**

public ObjectStreamField getField(String name) {

return getField(name, null);

}

/**

public String toString() {

return name + ": static final long serialVersionUID = " +

getSerialVersionUID() + "L;";

}

/**

static ObjectStreamClass lookup(Class<?> cl, boolean all) {

if (!(all || Serializable.class.isAssignableFrom(cl))) {

return null;

}

processQueue(Caches.localDescsQueue, Caches.localDescs);

WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);

Reference<?> ref = Caches.localDescs.get(key);

Object entry = null;

if (ref != null) {

entry = ref.get();

}

EntryFuture future = null;

if (entry == null) {

EntryFuture newEntry = new EntryFuture();

Reference<?> newRef = new SoftReference<>(newEntry);

do {

if (ref != null) {

Caches.localDescs.remove(key, ref);

}

ref = Caches.localDescs.putIfAbsent(key, newRef);

if (ref != null) {

entry = ref.get();

}

} while (ref != null && entry == null);

if (entry == null) {

future = newEntry;

}

}

if (entry instanceof ObjectStreamClass) { // check common case first

return (ObjectStreamClass) entry;

}

if (entry instanceof EntryFuture) {

future = (EntryFuture) entry;

if (future.getOwner() == Thread.currentThread()) {

/*

entry = null;

} else {

entry = future.get();

}

}

if (entry == null) {

try {

entry = new ObjectStreamClass(cl);

} catch (Throwable th) {

entry = th;

}

if (future.set(entry)) {

Caches.localDescs.put(key, new SoftReference<Object>(entry));

} else {

// nested lookup call already set future

entry = future.get();

}

}

if (entry instanceof ObjectStreamClass) {

return (ObjectStreamClass) entry;

} else if (entry instanceof RuntimeException) {

throw (RuntimeException) entry;

} else if (entry instanceof Error) {

throw (Error) entry;

} else {

throw new InternalError("unexpected entry: " + entry);

}

}

/**

private static class EntryFuture {

private static final Object unset = new Object();

private final Thread owner = Thread.currentThread();

private Object entry = unset;

/**

synchronized boolean set(Object entry) {

if (this.entry != unset) {

return false;

}

this.entry = entry;

notifyAll();

return true;

}

/**

synchronized Object get() {

boolean interrupted = false;

while (entry == unset) {

try {

wait();

} catch (InterruptedException ex) {

interrupted = true;

}

}

if (interrupted) {

AccessController.doPrivileged(

new PrivilegedAction<Void>() {

public Void run() {

Thread.currentThread().interrupt();

return null;

}

}

);

}

return entry;

}

/**

Thread getOwner() {

return owner;

}

}

/**

private ObjectStreamClass(final Class<?> cl) {

this.cl = cl;

name = cl.getName();

isProxy = Proxy.isProxyClass(cl);

isEnum = Enum.class.isAssignableFrom(cl);

serializable = Serializable.class.isAssignableFrom(cl);

externalizable = Externalizable.class.isAssignableFrom(cl);

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

superDesc = (superCl != null) ? lookup(superCl, false) : null;

localDesc = this;

if (serializable) {

AccessController.doPrivileged(new PrivilegedAction<Void>() {

public Void run() {

if (isEnum) {

suid = Long.valueOf(0);

fields = NO_FIELDS;

return null;

}

if (cl.isArray()) {

fields = NO_FIELDS;

return null;

}

suid = getDeclaredSUID(cl);

try {

fields = getSerialFields(cl);

computeFieldOffsets();

} catch (InvalidClassException e) {

serializeEx = deserializeEx =

new ExceptionInfo(e.classname, e.getMessage());

fields = NO_FIELDS;

}

if (externalizable) {

cons = getExternalizableConstructor(cl);

} else {

cons = getSerializableConstructor(cl);

writeObjectMethod = getPrivateMethod(cl, "writeObject",

new Class<?>[] { ObjectOutputStream.class },

Void.TYPE);

readObjectMethod = getPrivateMethod(cl, "readObject",

new Class<?>[] { ObjectInputStream.class },

Void.TYPE);

readObjectNoDataMethod = getPrivateMethod(

cl, "readObjectNoData", null, Void.TYPE);

hasWriteObjectData = (writeObjectMethod != null);

}

domains = getProtectionDomains(cons, cl);

writeReplaceMethod = getInheritableMethod(

cl, "writeReplace", null, Object.class);

readResolveMethod = getInheritableMethod(

cl, "readResolve", null, Object.class);

return null;

}

});

} else {

suid = Long.valueOf(0);

fields = NO_FIELDS;

}

try {

fieldRefl = getReflector(fields, this);

} catch (InvalidClassException ex) {

// field mismatches impossible when matching local fields vs. self

throw new InternalError(ex);

}

if (deserializeEx == null) {

if (isEnum) {

deserializeEx = new ExceptionInfo(name, "enum type");

} else if (cons == null) {

deserializeEx = new ExceptionInfo(name, "no valid constructor");

}

}

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

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

defaultSerializeEx = new ExceptionInfo(

name, "unmatched serializable field(s) declared");

}

}

initialized = true;

}

/**

ObjectStreamClass() {

}

/**

private ProtectionDomain noPermissionsDomain() {

PermissionCollection perms = new Permissions();

perms.setReadOnly();

return new ProtectionDomain(null, perms);

}

/**

private ProtectionDomain[] getProtectionDomains(Constructor<?> cons,

Class<?> cl) {

ProtectionDomain[] domains = null;

if (cons != null && cl.getClassLoader() != null

&& System.getSecurityManager() != null) {

Class<?> cls = cl;

Class<?> fnscl = cons.getDeclaringClass();

Set<ProtectionDomain> pds = null;

while (cls != fnscl) {

ProtectionDomain pd = cls.getProtectionDomain();

if (pd != null) {

if (pds == null) pds = new HashSet<>();

pds.add(pd);

}

cls = cls.getSuperclass();

if (cls == null) {

// that's not supposed to happen

// make a ProtectionDomain with no permission.

// should we throw instead?

if (pds == null) pds = new HashSet<>();

else pds.clear();

pds.add(noPermissionsDomain());

break;

}

}

if (pds != null) {

domains = pds.toArray(new ProtectionDomain[0]);

}

}

return domains;

}

/**

void initProxy(Class<?> cl,

ClassNotFoundException resolveEx,

ObjectStreamClass superDesc)

throws InvalidClassException

{

ObjectStreamClass osc = null;

if (cl != null) {

osc = lookup(cl, true);

if (!osc.isProxy) {

throw new InvalidClassException(

"cannot bind proxy descriptor to a non-proxy class");

}

}

this.cl = cl;

this.resolveEx = resolveEx;

this.superDesc = superDesc;

isProxy = true;

serializable = true;

suid = Long.valueOf(0);

fields = NO_FIELDS;

if (osc != null) {

localDesc = osc;

name = localDesc.name;

externalizable = localDesc.externalizable;

writeReplaceMethod = localDesc.writeReplaceMethod;

readResolveMethod = localDesc.readResolveMethod;

deserializeEx = localDesc.deserializeEx;

domains = localDesc.domains;

cons = localDesc.cons;

}

fieldRefl = getReflector(fields, localDesc);

initialized = true;

}

/**

void initNonProxy(ObjectStreamClass model,

Class<?> cl,

ClassNotFoundException resolveEx,

ObjectStreamClass superDesc)

throws InvalidClassException

{

long suid = Long.valueOf(model.getSerialVersionUID());

ObjectStreamClass osc = null;

if (cl != null) {

osc = lookup(cl, true);

if (osc.isProxy) {

throw new InvalidClassException(

"cannot bind non-proxy descriptor to a proxy class");

}

if (model.isEnum != osc.isEnum) {

throw new InvalidClassException(model.isEnum ?

"cannot bind enum descriptor to a non-enum class" :

"cannot bind non-enum descriptor to an enum class");

}

if (model.serializable == osc.serializable &&

!cl.isArray() &&

suid != osc.getSerialVersionUID()) {

throw new InvalidClassException(osc.name,

"local class incompatible: " +

"stream classdesc serialVersionUID = " + suid +

", local class serialVersionUID = " +

osc.getSerialVersionUID());

}

if (!classNamesEqual(model.name, osc.name)) {

throw new InvalidClassException(osc.name,

"local class name incompatible with stream class " +

"name \"" + model.name + "\"");

}

if (!model.isEnum) {

if ((model.serializable == osc.serializable) &&

(model.externalizable != osc.externalizable)) {

throw new InvalidClassException(osc.name,

"Serializable incompatible with Externalizable");

}

if ((model.serializable != osc.serializable) ||

(model.externalizable != osc.externalizable) ||

!(model.serializable || model.externalizable)) {

deserializeEx = new ExceptionInfo(

osc.name, "class invalid for deserialization");

}

}

}

this.cl = cl;

this.resolveEx = resolveEx;

this.superDesc = superDesc;

name = model.name;

this.suid = suid;

isProxy = false;

isEnum = model.isEnum;

serializable = model.serializable;

externalizable = model.externalizable;

hasBlockExternalData = model.hasBlockExternalData;

hasWriteObjectData = model.hasWriteObjectData;

fields = model.fields;

primDataSize = model.primDataSize;

numObjFields = model.numObjFields;

if (osc != null) {

localDesc = osc;

writeObjectMethod = localDesc.writeObjectMethod;

readObjectMethod = localDesc.readObjectMethod;

readObjectNoDataMethod = localDesc.readObjectNoDataMethod;

writeReplaceMethod = localDesc.writeReplaceMethod;

readResolveMethod = localDesc.readResolveMethod;

if (deserializeEx == null) {

deserializeEx = localDesc.deserializeEx;

}

domains = localDesc.domains;

cons = localDesc.cons;

}

fieldRefl = getReflector(fields, localDesc);

// reassign to matched fields so as to reflect local unshared settings

fields = fieldRefl.getFields();

initialized = true;

}

/**

void readNonProxy(ObjectInputStream in)

throws IOException, ClassNotFoundException

{

name = in.readUTF();

suid = Long.valueOf(in.readLong());

isProxy = false;

byte flags = in.readByte();

hasWriteObjectData =

((flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0);

hasBlockExternalData =

((flags & ObjectStreamConstants.SC_BLOCK_DATA) != 0);

externalizable =

((flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0);

boolean sflag =

((flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0);

if (externalizable && sflag) {

throw new InvalidClassException(

name, "serializable and externalizable flags conflict");

}

serializable = externalizable || sflag;

isEnum = ((flags & ObjectStreamConstants.SC_ENUM) != 0);

if (isEnum && suid.longValue() != 0L) {

throw new InvalidClassException(name,

"enum descriptor has non-zero serialVersionUID: " + suid);

}

int numFields = in.readShort();

if (isEnum && numFields != 0) {

throw new InvalidClassException(name,

"enum descriptor has non-zero field count: " + numFields);

}

fields = (numFields > 0) ?

new ObjectStreamField[numFields] : NO_FIELDS;

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

char tcode = (char) in.readByte();

String fname = in.readUTF();

String signature = ((tcode == 'L') || (tcode == '[')) ?

in.readTypeString() : new String(new char[] { tcode });

try {

fields[i] = new ObjectStreamField(fname, signature, false);

} catch (RuntimeException e) {

throw (IOException) new InvalidClassException(name,

"invalid descriptor for field " + fname).initCause(e);

}

}

computeFieldOffsets();

}

/**

void writeNonProxy(ObjectOutputStream out) throws IOException {

out.writeUTF(name);

out.writeLong(getSerialVersionUID());

byte flags = 0;

if (externalizable) {

flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;

int protocol = out.getProtocolVersion();

if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) {

flags |= ObjectStreamConstants.SC_BLOCK_DATA;

}

} else if (serializable) {

flags |= ObjectStreamConstants.SC_SERIALIZABLE;

}

if (hasWriteObjectData) {

flags |= ObjectStreamConstants.SC_WRITE_METHOD;

}

if (isEnum) {

flags |= ObjectStreamConstants.SC_ENUM;

}

out.writeByte(flags);

out.writeShort(fields.length);

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

ObjectStreamField f = fields[i];

out.writeByte(f.getTypeCode());

out.writeUTF(f.getName());

if (!f.isPrimitive()) {

out.writeTypeString(f.getTypeString());

}

}

}

/**

ClassNotFoundException getResolveException() {

return resolveEx;

}

/**

private final void requireInitialized() {

if (!initialized)

throw new InternalError("Unexpected call when not initialized");

}

/**

void checkDeserialize() throws InvalidClassException {

requireInitialized();

if (deserializeEx != null) {

throw deserializeEx.newInvalidClassException();

}

}

/**

void checkSerialize() throws InvalidClassException {

requireInitialized();

if (serializeEx != null) {

throw serializeEx.newInvalidClassException();

}

}

/**

void checkDefaultSerialize() throws InvalidClassException {

requireInitialized();

if (defaultSerializeEx != null) {

throw defaultSerializeEx.newInvalidClassException();

}

}

/**

ObjectStreamClass getSuperDesc() {

requireInitialized();

return superDesc;

}

/**

ObjectStreamClass getLocalDesc() {

requireInitialized();

return localDesc;

}

/**

ObjectStreamField[] getFields(boolean copy) {

return copy ? fields.clone() : fields;

}

/**

ObjectStreamField getField(String name, Class<?> type) {

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

ObjectStreamField f = fields[i];

if (f.getName().equals(name)) {

if (type == null ||

(type == Object.class && !f.isPrimitive()))

{

return f;

}

Class<?> ftype = f.getType();

if (ftype != null && type.isAssignableFrom(ftype)) {

return f;

}

}

}

return null;

}

/**

boolean isProxy() {

requireInitialized();

return isProxy;

}

/**

boolean isEnum() {

requireInitialized();

return isEnum;

}

/**

boolean isExternalizable() {

requireInitialized();

return externalizable;

}

/**

boolean isSerializable() {

requireInitialized();

return serializable;

}

/**

boolean hasBlockExternalData() {

requireInitialized();