org.apache.axis2.context.externalize.SafeObjectInputStream Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of axis2-kernel Show documentation
Show all versions of axis2-kernel Show documentation
Core Parts of Axis2. This includes Axis2 engine, Client API, Addressing support, etc.,
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.axis2.context.externalize;
import org.apache.axis2.AxisFault;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectStreamConstants;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* A SafeObjectInputStream reads data that was written by SafeObjectOutputStream
*
* @see SafeObjectInput
*/
public class SafeObjectInputStream implements ObjectInput, ObjectStreamConstants {
private static final Log log = LogFactory.getLog(SafeObjectInputStream.class);
private static final boolean isDebug = log.isDebugEnabled();
// All data is read from the delegated ObjectInput
ObjectInput in = null;
final ObjectInput original;
// A buffer is used when Object is persisted as bytes
private byte[] buffer = null;
private static final int BUFFER_MIN_SIZE = 4096;
/**
* Add the SafeObjectInputStream if necessary
* @param in
* @return
*/
public static SafeObjectInputStream install(ObjectInput in) {
if (in instanceof SafeObjectInputStream) {
return (SafeObjectInputStream) in;
}
return new SafeObjectInputStream(in);
}
/**
* Intentionally private. Callers should use the install method to add the SafeObjectInputStream
* into the stream.
* @param in
*/
private SafeObjectInputStream(ObjectInput in) {
original = in;
if (log.isDebugEnabled()) {
this.in = new DebugObjectInput(original);
} else {
this.in = original;
}
}
// Delegated Methods
public int available() throws IOException {
return in.available();
}
public void close() throws IOException {
in.close();
}
public int read() throws IOException {
return in.read();
}
public int read(byte[] b, int off, int len) throws IOException {
return in.read(b, off, len);
}
public int read(byte[] b) throws IOException {
return in.read(b);
}
public boolean readBoolean() throws IOException {
return in.readBoolean();
}
public byte readByte() throws IOException {
return in.readByte();
}
public char readChar() throws IOException {
return in.readChar();
}
public double readDouble() throws IOException {
return in.readDouble();
}
public float readFloat() throws IOException {
return in.readFloat();
}
public void readFully(byte[] b, int off, int len) throws IOException {
in.readFully(b, off, len);
}
public void readFully(byte[] b) throws IOException {
in.readFully(b);
}
public int readInt() throws IOException {
return in.readInt();
}
public String readLine() throws IOException {
return in.readLine();
}
public long readLong() throws IOException {
return in.readLong();
}
public Object readObject() throws ClassNotFoundException, IOException {
return readObjectOverride();
}
public short readShort() throws IOException {
return in.readShort();
}
public int readUnsignedByte() throws IOException {
return in.readUnsignedByte();
}
public int readUnsignedShort() throws IOException {
return in.readUnsignedShort();
}
public String readUTF() throws IOException {
return in.readUTF();
}
public long skip(long n) throws IOException {
return in.skip(n);
}
public int skipBytes(int n) throws IOException {
return in.skipBytes(n);
}
// Value Add Methods
/**
* Read the input stream and place the key/value pairs in a hashmap
* @return HashMap or null
* @throws IOException
* @see SafeObjectOutputStream.writeMap()
*/
public HashMap readHashMap() throws IOException {
HashMap hashMap = new HashMap();
return (HashMap) readMap(hashMap);
}
/**
* Read the input stream and place the key/value pairs in the
* indicated Map
* @param map input map
* @return map or null
* @throws IOException
* @see SafeObjectOutputStream.writeMap()
*/
public Map readMap(Map map) throws IOException {
boolean isActive = in.readBoolean();
if (!isActive) {
return null;
}
while (in.readBoolean()) {
Object key = null;
Object value = null;
boolean isObjectForm = in.readBoolean();
try {
if (isObjectForm) {
if (isDebug) {
log.debug(" reading using object form");
}
// Read the key and value directly
key = in.readObject();
value = in.readObject();
} else {
if (isDebug) {
log.debug(" reading using byte form");
}
// Get the byte stream
ByteArrayInputStream bais = getByteStream(in);
// Now get the real key and value
ObjectInputStream tempOIS = createObjectInputStream(bais);
key = tempOIS.readObject();
value = tempOIS.readObject();
tempOIS.close();
bais.close();
}
// Put the key and value in the map
if (isDebug) {
log.debug("Read key=" + valueName(key) + " value="+valueName(value));
}
map.put(key, value);
} catch (ClassNotFoundException e) {
// Swallow the error and try to continue
log.error(e);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw AxisFault.makeFault(e);
}
}
return map;
}
/**
* Read the input stream and place objects in an ArrayList
* @return ArrayList or null
* @throws IOException
* @see SafeObjectInputStream.writeList()
*/
public ArrayList readArrayList() throws IOException {
List ll = new ArrayList();
return (ArrayList) readList(ll);
}
/**
* Read the input stream and place objects in a LinkedList
* @return LinkedList or null
* @throws IOException
* @see SafeObjectInputStream.writeList()
*/
public LinkedList readLinkedList() throws IOException {
List ll = new LinkedList();
return (LinkedList) readList(ll);
}
/**
* Read hte input stream and place objects in the specified List
* @param list List
* @return List or null
* @throws IOException
* @see SafeObjectInputStream.writeList()
*/
public List readList(List list) throws IOException {
boolean isActive = in.readBoolean();
if (!isActive) {
return null;
}
while (in.readBoolean()) {
Object value;
boolean isObjectForm = in.readBoolean();
try {
if (isObjectForm) {
if (isDebug) {
log.debug(" reading using object form");
}
// Read the value directly
value = in.readObject();
} else {
if (isDebug) {
log.debug(" reading using byte form");
}
// Get the byte stream
ByteArrayInputStream bais = getByteStream(in);
// Now get the real key and value
ObjectInputStream tempOIS = createObjectInputStream(bais);
value = tempOIS.readObject();
tempOIS.close();
bais.close();
}
// Put the key and value in the list
if (isDebug) {
log.debug("Read value="+valueName(value));
}
list.add(value);
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw AxisFault.makeFault(e);
}
}
return list;
}
/**
* Reads the object using the same format that was written.
*
* EXPECTED FORMATS
* boolean=false
* return null Object
*
*
* boolean=true
* boolean=true
* return Object read from inputStream
*
*
* boolean=true
* boolean=false
* int=nuber of bytes
* bytes
* return Object read from bytes
*
* @return Object or null
* @throws IOException
* @throws ClassNotFoundException
*/
private Object readObjectOverride() throws IOException, ClassNotFoundException {
boolean isActive = in.readBoolean();
if (!isActive) {
if (isDebug) {
log.debug("Read object=null");
}
return null;
}
Object obj = null;
boolean isObjectForm = in.readBoolean();
if (isObjectForm) {
// Read the object directly
if (isDebug) {
log.debug(" reading using object form");
}
obj = in.readObject();
} else {
if (isDebug) {
log.debug(" reading using byte form");
}
// Get the byte stream
ByteArrayInputStream bais = getByteStream(in);
// Now get the real object
ObjectInputStream tempOIS = createObjectInputStream(bais);
obj = tempOIS.readObject();
tempOIS.close();
bais.close();
}
if (isDebug) {
log.debug("Read object=" + valueName(obj));
}
return obj;
}
private String valueName(Object obj) {
if (obj == null) {
return "null";
} else if (obj instanceof String) {
return (String) obj;
} else {
return "Object of class = " + obj.getClass().getName();
}
}
/**
* Get the byte stream for an object that is written using the
* byte format.
* EXPECTED format
* int (number of bytes)
* bytes
*
* @param in
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
private ByteArrayInputStream getByteStream(ObjectInput in) throws IOException, ClassNotFoundException {
// Read the length
int size = in.readInt();
// Fill our temporary buffer
if (buffer == null || buffer.length < size) {
int allocSize = (size > BUFFER_MIN_SIZE) ? size : BUFFER_MIN_SIZE;
buffer = new byte[allocSize];
}
in.readFully(buffer, 0, size);
// Return a stream backed by the buffer
return new ByteArrayInputStream(buffer, 0, size);
}
private ObjectInputStream createObjectInputStream(InputStream is) throws IOException {
// The created ObjectInputStream must use the same class/object resolution
// code that is used by the original ObjectInput
return new ObjectInputStreamWithCL(is);
}
}