v1.5beta1/modules/kernel/src/org/apache/axis2/context/externalize/SafeObjectInputStream.java - axis-axis2-java-core - Git at Google

 /*
  * 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);
     }
 }
	/*
	* 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);
	}
	}