axiom/modules/axiom-api/src/main/java/org/apache/axiom/attachments/Attachments.java - ws-axiom - Git at Google

 /*
  * Copyright 2004,2005 The Apache Software Foundation.
  *
  * Licensed 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.axiom.attachments;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PushbackInputStream;
 import java.util.Set;
 import java.util.TreeMap;

 import javax.activation.DataHandler;
 import javax.mail.MessagingException;
 import javax.mail.internet.ContentType;
 import javax.mail.internet.ParseException;

 import org.apache.axiom.om.OMException;
 import org.apache.axiom.om.impl.MTOMConstants;
 import org.apache.axiom.om.util.UUIDGenerator;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 public class Attachments {

     /**
      * <code>ContentType</code> of the MIME message
      */
     ContentType contentType;

     /**
      * Mime <code>boundary</code> which separates mime parts
      */
     byte[] boundary;

     /**
      * <code>applicationType</code> used to distinguish between MTOM & SWA If
      * the message is MTOM optimised type is application/xop+xml If the message
      * is SWA, type is ??have to find out
      */
     String applicationType;

     /**
      * <code>pushbackInStream</code> stores the reference to the incoming
      * stream A PushbackStream has the ability to "push back" or "unread" one
      * byte.
      */
     PushbackInputStream pushbackInStream;

     /**
      * <code>attachmentsMap</code> stores the Data Handlers of the already parsed Mime Body
      * Parts. This ordered Map is keyed using the content-ID's.
      */
     TreeMap attachmentsMap;

     /**
      * <code>partIndex</code>- Number of Mime parts parsed
      */
     int partIndex = 0;

     /** Container to hold streams for direct access */
     IncomingAttachmentStreams streams = null;

     /** <code>boolean</code> Indicating if any streams have been directly requested */
     private boolean streamsRequested = false;

     /** <code>boolean</code> Indicating if any data handlers have been directly requested */
     private boolean partsRequested = false;

     /**
      * <code>endOfStreamReached</code> flag which is to be set by
      * MIMEBodyPartStream when MIME message terminator is found.
      */
     private boolean endOfStreamReached;


     /**
 	 * <code>noStreams</code> flag which is to be set when this class is
 	 * instantiated by the SwA API to handle programatic added attachements. An
 	 * InputStream with attachments is not present at that occation.
 	 */
     private boolean noStreams = false;

     private String firstPartId;

     private boolean fileCacheEnable;

     private String attachmentRepoDir;

     private int fileStorageThreshold;

     protected Log log = LogFactory.getLog(getClass());


     /**
      * Moves the pointer to the beginning of the first MIME part. Reads
      * till first MIME boundary is found or end of stream is reached.
      *
      * @param inStream
      * @param contentTypeString
      * @param fileCacheEnable
      * @param attachmentRepoDir
      * @throws OMException
      */
     public Attachments(InputStream inStream, String contentTypeString,
                        boolean fileCacheEnable, String attachmentRepoDir,
                        String fileThreshold) throws OMException {
         this.attachmentRepoDir = attachmentRepoDir;
         this.fileCacheEnable = fileCacheEnable;
         if (fileThreshold != null && (!"".equals(fileThreshold))) {
             this.fileStorageThreshold = Integer.parseInt(fileThreshold);
         } else {
             this.fileStorageThreshold = 1;
         }
         attachmentsMap = new TreeMap();
         try {
             contentType = new ContentType(contentTypeString);
         } catch (ParseException e) {
             throw new OMException(
                     "Invalid Content Type Field in the Mime Message"
                     , e);
         }
         // Boundary always have the prefix "--".
         this.boundary = ("--" + contentType.getParameter("boundary"))
                 .getBytes();

         // do we need to wrap InputStream from a BufferedInputStream before
         // wrapping from PushbackStream
         pushbackInStream = new PushbackInputStream(inStream,
                                                    (this.boundary.length + 2));

         // Move the read pointer to the beginning of the first part
         // read till the end of first boundary
         while (true) {
             int value;
             try {
                 value = pushbackInStream.read();
                 if ((byte) value == boundary[0]) {
                     int boundaryIndex = 0;
                     while ((boundaryIndex < boundary.length)
                            && ((byte) value == boundary[boundaryIndex])) {
                         value = pushbackInStream.read();
                         if (value == -1) {
                             throw new OMException(
                                     "Unexpected End of Stream while searching for first Mime Boundary");
                         }
                         boundaryIndex++;
                     }
                     if (boundaryIndex == boundary.length) { // boundary found
                         pushbackInStream.read();
                         break;
                     }
                 } else if ((byte) value == -1) {
                     throw new OMException(
                             "Mime parts not found. Stream ended while searching for the boundary");
                 }
             } catch (IOException e1) {
                 throw new OMException("Stream Error" + e1.toString(), e1);
             }
         }

         // Read the SOAP part and cache it
         getDataHandler(getSOAPPartContentID());

         // Now reset partsRequested. SOAP part is a special case which is always
         // read beforehand, regardless of request.
         partsRequested = false;
     }

     /**
      * Sets file cache to false.
      *
      * @param inStream
      * @param contentTypeString
      * @throws OMException
      */
     public Attachments(InputStream inStream, String contentTypeString)
             throws OMException {
         this(inStream, contentTypeString, false, null, null);
     }

     /**
      * Use this constructor when instantiating this to store the attachments set programatically through the SwA API.
      */
     public Attachments()
     {
     	attachmentsMap = new TreeMap();
     	noStreams= true;
     }

     /**
      * @return whether Message Type is SOAP with Attachments or MTOM optimized,
      *         by checking the application type parameter in the Content Type.
      */
     public String getAttachmentSpecType() {
         if (this.applicationType == null) {
             applicationType = contentType.getParameter("type");
             if ((MTOMConstants.MTOM_TYPE).equalsIgnoreCase(applicationType)) {
                 this.applicationType = MTOMConstants.MTOM_TYPE;
             } else if ((MTOMConstants.SWA_TYPE).equalsIgnoreCase(applicationType)) {
                 this.applicationType = MTOMConstants.SWA_TYPE;
             } else {
                 throw new OMException(
                         "Invalid Application type. Support available for MTOM & SwA/SOAP 1.l only.");
             }
         }
         return this.applicationType;
     }

     /**
      * Checks whether the MIME part is already parsed by checking the
      * attachments HashMap. If it is not parsed yet then call the getNextPart()
      * till the required part is found.
      *
      * @param blobContentID (without the surrounding angle brackets and "cid:" prefix)
      * @return The DataHandler of the mime part referred by the Content-Id or
      *   *null* if the mime part referred by the content-id does not exist
      */
     public DataHandler getDataHandler(String blobContentID) {
         DataHandler dataHandler;
         if (attachmentsMap.containsKey(blobContentID)) {
             dataHandler = (DataHandler) attachmentsMap.get(blobContentID);
             return dataHandler;
         } else if (!noStreams){
             //This loop will be terminated by the Exceptions thrown if the Mime
             // part searching was not found
             while ((dataHandler = this.getNextPartDataHandler())!=null) {
                 if (attachmentsMap.containsKey(blobContentID)) {
                     dataHandler = (DataHandler) attachmentsMap.get(blobContentID);
                     return dataHandler;
                 }
             }
         }
         return null;
     }

     /**
 	 * Programatically adding an SOAP with Attachments(SwA) Attachment. These
 	 * attachments will get serialized only if SOAP with Attachments is enabled.
 	 *
 	 * @param contentID
 	 * @param dataHandler
 	 */
     public void addDataHandler(String contentID, DataHandler dataHandler)
     {
     	attachmentsMap.put(contentID,dataHandler);
     }

     /**
      * @return the InputStream which includes the SOAP Envelope. It assumes that
      *         the root mime part is always pointed by "start" parameter in
      *         content-type.
      */
     public InputStream getSOAPPartInputStream() throws OMException {
         DataHandler dh;
         if (noStreams)
         {
         	throw new OMException("Invalid operation. Attachments are created programatically.");
         }
         try {
             dh = getDataHandler(getSOAPPartContentID());
             if (dh == null) {
                 throw new OMException(
                         "Mandatory Root MIME part containing the SOAP Envelope is missing");
             }
             return dh.getInputStream();
         } catch (IOException e) {
             throw new OMException(
                     "Problem with DataHandler of the Root Mime Part. ", e);
         }
     }

     /**
      * @return the Content-ID of the SOAP part It'll be the value Start
      *         Parameter of Content-Type header if given in the Content type of
      *         the MIME message. Else it'll be the content-id of the first MIME
      *         part of the MIME message
      */
     private String getSOAPPartContentID() {
         String rootContentID = contentType.getParameter("start");

         // to handle the Start parameter not mentioned situation
         if (rootContentID == null) {
             if (partIndex == 0) {
                 getNextPartDataHandler();
             }
             rootContentID = firstPartId;
         } else {
             rootContentID = rootContentID.trim();

             if ((rootContentID.indexOf("<") > -1)
                 & (rootContentID.indexOf(">") > -1)) {
                 rootContentID = rootContentID.substring(1, (rootContentID
                         .length() - 1));
             }
         }
         // Strips off the "cid" part from content-id
         if ("cid".equalsIgnoreCase(rootContentID.substring(0, 3))) {
             rootContentID = rootContentID.substring(4);
         }
         return rootContentID;
     }

     public String getSOAPPartContentType() {
     	if (!noStreams) {
 			DataHandler soapPart = getDataHandler(getSOAPPartContentID());
 			return soapPart.getContentType();
 		}else
 		{
 			throw new OMException("The attachments map was created programatically. Unsupported operation.");
 		}
     }

     /**
 	 * Stream based access
 	 *
 	 * @return The stream container of type
 	 *         <code>IncomingAttachmentStreams</code>
 	 * @throws IllegalStateException
 	 *             if application has alreadt started using Part's directly
 	 */
     public IncomingAttachmentStreams getIncomingAttachmentStreams() throws IllegalStateException {
     	if (partsRequested) {
     		throw new IllegalStateException("The attachments stream can only be accessed once; either by using the IncomingAttachmentStreams class or by getting a collection of AttachmentPart objects. They cannot both be called within the life time of the same service request.");
     	}
     	if (noStreams)
     	{
     		throw new IllegalStateException("The attachments map was created programatically. No streams are available.");
     	}

     	streamsRequested = true;

     	if (this.streams == null) {
        		BoundaryDelimitedStream boundaryDelimitedStream =
                 new BoundaryDelimitedStream(pushbackInStream,
                         boundary, 1024);

        		this.streams = new MultipartAttachmentStreams(boundaryDelimitedStream);
     	}

     	return this.streams;
     }

     public String[] getAllContentIDs() {
         Set keys = getContentIDSet();
         return (String[]) keys.toArray(new String[keys.size()]);
     }

     public Set getContentIDSet() {
         DataHandler dataHandler;
         while (!noStreams & true) {
             dataHandler = this.getNextPartDataHandler();
             if (dataHandler == null) {
                 break;
             }
         }
         return attachmentsMap.keySet();
     }

     /**
 	 * endOfStreamReached will be set to true if the message ended in MIME Style
 	 * having "--" suffix with the last mime boundary
 	 *
 	 * @param value
 	 */
     protected void setEndOfStream(boolean value) {
         this.endOfStreamReached = value;
     }

     /**
      * @return the Next valid MIME part + store the Part in the Parts List
      * @throws OMException throw if content id is null or if two MIME parts contain the
      *                     same content-ID & the exceptions throws by getPart()
      */
     private DataHandler getNextPartDataHandler() throws OMException {
     	if (endOfStreamReached)
     	{
     		return null;
     	}
         Part nextPart;
         nextPart = getPart();
         if (nextPart==null)
         {
         	return null;
         } else
 			try {
 				if (nextPart.getSize()>0) {
 				    String partContentID;
 				    try {
 				        partContentID = nextPart.getContentID();

 				        if (partContentID == null & partIndex == 1) {
 				        	String id = "firstPart_"+UUIDGenerator.getUUID();
 				            attachmentsMap.put(id, nextPart);
 				            firstPartId = id;
 				            return nextPart.getDataHandler();
 				        }
 				        if (partContentID == null) {
 				            throw new OMException(
 				                    "Part content ID cannot be blank for non root MIME parts");
 				        }
 				        if ((partContentID.indexOf("<") > -1)
 				            & (partContentID.indexOf(">") > -1)) {
 				            partContentID = partContentID.substring(1, (partContentID
 				                    .length() - 1));

 				        } else if (partIndex == 1) {
 				            firstPartId = partContentID;
 				        }
 				        if (attachmentsMap.containsKey(partContentID)) {
 				            throw new OMException(
 				                    "Two MIME parts with the same Content-ID not allowed.");
 				        }
 				        attachmentsMap.put(partContentID, nextPart.getDataHandler());
 				        return nextPart.getDataHandler();
 				    } catch (MessagingException e) {
 				        throw new OMException("Error reading Content-ID from the Part."
 				                              + e);
 				    }
 				} // This will take care if stream ended without having MIME
 				// message terminator
 				else {
 					return null;
 				}
 			} catch (MessagingException e) {
 				throw new OMException(e);
 			}
     }

     /**
      * @return This will return the next available MIME part in the stream.
      * @throws OMException if Stream ends while reading the next part...
      */
     private Part getPart() throws OMException {

     	if (streamsRequested) {
     		throw new IllegalStateException("The attachments stream can only be accessed once; either by using the IncomingAttachmentStreams class or by getting a collection of AttachmentPart objects. They cannot both be called within the life time of the same service request.");
     	}

     	partsRequested = true;

         Part part;

         try {
             if (fileCacheEnable) {
                 try {
                     MIMEBodyPartInputStream partStream;
                     byte[] buffer = new byte[fileStorageThreshold];
                     partStream = new MIMEBodyPartInputStream(pushbackInStream,
                                                              boundary, this);
                     int count = 0;
                     int value;
                     // Make sure *not* to modify this to a Short Circuit "&". If
                     // removed a byte will be lost
                     while (count != fileStorageThreshold
                            && (!partStream.getBoundaryStatus())) {
                         value = partStream.read();
                         buffer[count] = (byte) value;
                         count++;
                     }
                     if (count == fileStorageThreshold) {
                         PushbackFilePartInputStream filePartStream = new PushbackFilePartInputStream(
                                 partStream, buffer);
                         part = new PartOnFile(filePartStream, attachmentRepoDir);
                     } else {
                         ByteArrayInputStream byteArrayInStream = new ByteArrayInputStream(
                                 buffer, 0, count - 1);
                         part = new PartOnMemory(byteArrayInStream);
                     }
                 } catch (Exception e) {
                     throw new OMException("Error creating temporary File.", e);
                 }
             } else {
                 MIMEBodyPartInputStream partStream;
                 partStream = new MIMEBodyPartInputStream(pushbackInStream,
                                                          boundary, this);
                 part = new PartOnMemory(partStream);
             }

         } catch (MessagingException e) {
             throw new OMException(e);
         }
         partIndex++;
         return part;
     }
 }
	/*
	* Copyright 2004,2005 The Apache Software Foundation.
	*
	* Licensed 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.axiom.attachments;

	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.PushbackInputStream;
	import java.util.Set;
	import java.util.TreeMap;

	import javax.activation.DataHandler;
	import javax.mail.MessagingException;
	import javax.mail.internet.ContentType;
	import javax.mail.internet.ParseException;

	import org.apache.axiom.om.OMException;
	import org.apache.axiom.om.impl.MTOMConstants;
	import org.apache.axiom.om.util.UUIDGenerator;
	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;

	public class Attachments {

	/**
	* <code>ContentType</code> of the MIME message
	*/
	ContentType contentType;

	/**
	* Mime <code>boundary</code> which separates mime parts
	*/
	byte[] boundary;

	/**
	* <code>applicationType</code> used to distinguish between MTOM & SWA If
	* the message is MTOM optimised type is application/xop+xml If the message
	* is SWA, type is ??have to find out
	*/
	String applicationType;

	/**
	* <code>pushbackInStream</code> stores the reference to the incoming
	* stream A PushbackStream has the ability to "push back" or "unread" one
	* byte.
	*/
	PushbackInputStream pushbackInStream;

	/**
	* <code>attachmentsMap</code> stores the Data Handlers of the already parsed Mime Body
	* Parts. This ordered Map is keyed using the content-ID's.
	*/
	TreeMap attachmentsMap;

	/**
	* <code>partIndex</code>- Number of Mime parts parsed
	*/
	int partIndex = 0;

	/** Container to hold streams for direct access */
	IncomingAttachmentStreams streams = null;

	/** <code>boolean</code> Indicating if any streams have been directly requested */
	private boolean streamsRequested = false;

	/** <code>boolean</code> Indicating if any data handlers have been directly requested */
	private boolean partsRequested = false;

	/**
	* <code>endOfStreamReached</code> flag which is to be set by
	* MIMEBodyPartStream when MIME message terminator is found.
	*/
	private boolean endOfStreamReached;


	/**
	* <code>noStreams</code> flag which is to be set when this class is
	* instantiated by the SwA API to handle programatic added attachements. An
	* InputStream with attachments is not present at that occation.
	*/
	private boolean noStreams = false;

	private String firstPartId;

	private boolean fileCacheEnable;

	private String attachmentRepoDir;

	private int fileStorageThreshold;

	protected Log log = LogFactory.getLog(getClass());


	/**
	* Moves the pointer to the beginning of the first MIME part. Reads
	* till first MIME boundary is found or end of stream is reached.
	*
	* @param inStream
	* @param contentTypeString
	* @param fileCacheEnable
	* @param attachmentRepoDir
	* @throws OMException
	*/
	public Attachments(InputStream inStream, String contentTypeString,
	boolean fileCacheEnable, String attachmentRepoDir,
	String fileThreshold) throws OMException {
	this.attachmentRepoDir = attachmentRepoDir;
	this.fileCacheEnable = fileCacheEnable;
	if (fileThreshold != null && (!"".equals(fileThreshold))) {
	this.fileStorageThreshold = Integer.parseInt(fileThreshold);
	} else {
	this.fileStorageThreshold = 1;
	}
	attachmentsMap = new TreeMap();
	try {
	contentType = new ContentType(contentTypeString);
	} catch (ParseException e) {
	throw new OMException(
	"Invalid Content Type Field in the Mime Message"
	, e);
	}
	// Boundary always have the prefix "--".
	this.boundary = ("--" + contentType.getParameter("boundary"))
	.getBytes();

	// do we need to wrap InputStream from a BufferedInputStream before
	// wrapping from PushbackStream
	pushbackInStream = new PushbackInputStream(inStream,
	(this.boundary.length + 2));

	// Move the read pointer to the beginning of the first part
	// read till the end of first boundary
	while (true) {
	int value;
	try {
	value = pushbackInStream.read();
	if ((byte) value == boundary[0]) {
	int boundaryIndex = 0;
	while ((boundaryIndex < boundary.length)
	&& ((byte) value == boundary[boundaryIndex])) {
	value = pushbackInStream.read();
	if (value == -1) {
	throw new OMException(
	"Unexpected End of Stream while searching for first Mime Boundary");
	}
	boundaryIndex++;
	}
	if (boundaryIndex == boundary.length) { // boundary found
	pushbackInStream.read();
	break;
	}
	} else if ((byte) value == -1) {
	throw new OMException(
	"Mime parts not found. Stream ended while searching for the boundary");
	}
	} catch (IOException e1) {
	throw new OMException("Stream Error" + e1.toString(), e1);
	}
	}

	// Read the SOAP part and cache it
	getDataHandler(getSOAPPartContentID());

	// Now reset partsRequested. SOAP part is a special case which is always
	// read beforehand, regardless of request.
	partsRequested = false;
	}

	/**
	* Sets file cache to false.
	*
	* @param inStream
	* @param contentTypeString
	* @throws OMException
	*/
	public Attachments(InputStream inStream, String contentTypeString)
	throws OMException {
	this(inStream, contentTypeString, false, null, null);
	}

	/**
	* Use this constructor when instantiating this to store the attachments set programatically through the SwA API.
	*/
	public Attachments()
	{
	attachmentsMap = new TreeMap();
	noStreams= true;
	}

	/**
	* @return whether Message Type is SOAP with Attachments or MTOM optimized,
	* by checking the application type parameter in the Content Type.
	*/
	public String getAttachmentSpecType() {
	if (this.applicationType == null) {
	applicationType = contentType.getParameter("type");
	if ((MTOMConstants.MTOM_TYPE).equalsIgnoreCase(applicationType)) {
	this.applicationType = MTOMConstants.MTOM_TYPE;
	} else if ((MTOMConstants.SWA_TYPE).equalsIgnoreCase(applicationType)) {
	this.applicationType = MTOMConstants.SWA_TYPE;
	} else {
	throw new OMException(
	"Invalid Application type. Support available for MTOM & SwA/SOAP 1.l only.");
	}
	}
	return this.applicationType;
	}

	/**
	* Checks whether the MIME part is already parsed by checking the
	* attachments HashMap. If it is not parsed yet then call the getNextPart()
	* till the required part is found.
	*
	* @param blobContentID (without the surrounding angle brackets and "cid:" prefix)
	* @return The DataHandler of the mime part referred by the Content-Id or
	* null if the mime part referred by the content-id does not exist
	*/
	public DataHandler getDataHandler(String blobContentID) {
	DataHandler dataHandler;
	if (attachmentsMap.containsKey(blobContentID)) {
	dataHandler = (DataHandler) attachmentsMap.get(blobContentID);
	return dataHandler;
	} else if (!noStreams){
	//This loop will be terminated by the Exceptions thrown if the Mime
	// part searching was not found
	while ((dataHandler = this.getNextPartDataHandler())!=null) {
	if (attachmentsMap.containsKey(blobContentID)) {
	dataHandler = (DataHandler) attachmentsMap.get(blobContentID);
	return dataHandler;
	}
	}
	}
	return null;
	}

	/**
	* Programatically adding an SOAP with Attachments(SwA) Attachment. These
	* attachments will get serialized only if SOAP with Attachments is enabled.
	*
	* @param contentID
	* @param dataHandler
	*/
	public void addDataHandler(String contentID, DataHandler dataHandler)
	{
	attachmentsMap.put(contentID,dataHandler);
	}

	/**
	* @return the InputStream which includes the SOAP Envelope. It assumes that
	* the root mime part is always pointed by "start" parameter in
	* content-type.
	*/
	public InputStream getSOAPPartInputStream() throws OMException {
	DataHandler dh;
	if (noStreams)
	{
	throw new OMException("Invalid operation. Attachments are created programatically.");
	}
	try {
	dh = getDataHandler(getSOAPPartContentID());
	if (dh == null) {
	throw new OMException(
	"Mandatory Root MIME part containing the SOAP Envelope is missing");
	}
	return dh.getInputStream();
	} catch (IOException e) {
	throw new OMException(
	"Problem with DataHandler of the Root Mime Part. ", e);
	}
	}

	/**
	* @return the Content-ID of the SOAP part It'll be the value Start
	* Parameter of Content-Type header if given in the Content type of
	* the MIME message. Else it'll be the content-id of the first MIME
	* part of the MIME message
	*/
	private String getSOAPPartContentID() {
	String rootContentID = contentType.getParameter("start");

	// to handle the Start parameter not mentioned situation
	if (rootContentID == null) {
	if (partIndex == 0) {
	getNextPartDataHandler();
	}
	rootContentID = firstPartId;
	} else {
	rootContentID = rootContentID.trim();

	if ((rootContentID.indexOf("<") > -1)
	& (rootContentID.indexOf(">") > -1)) {
	rootContentID = rootContentID.substring(1, (rootContentID
	.length() - 1));
	}
	}
	// Strips off the "cid" part from content-id
	if ("cid".equalsIgnoreCase(rootContentID.substring(0, 3))) {
	rootContentID = rootContentID.substring(4);
	}
	return rootContentID;
	}

	public String getSOAPPartContentType() {
	if (!noStreams) {
	DataHandler soapPart = getDataHandler(getSOAPPartContentID());
	return soapPart.getContentType();
	}else
	{
	throw new OMException("The attachments map was created programatically. Unsupported operation.");
	}
	}

	/**
	* Stream based access
	*
	* @return The stream container of type
	* <code>IncomingAttachmentStreams</code>
	* @throws IllegalStateException
	* if application has alreadt started using Part's directly
	*/
	public IncomingAttachmentStreams getIncomingAttachmentStreams() throws IllegalStateException {
	if (partsRequested) {
	throw new IllegalStateException("The attachments stream can only be accessed once; either by using the IncomingAttachmentStreams class or by getting a collection of AttachmentPart objects. They cannot both be called within the life time of the same service request.");
	}
	if (noStreams)
	{
	throw new IllegalStateException("The attachments map was created programatically. No streams are available.");
	}

	streamsRequested = true;

	if (this.streams == null) {
	BoundaryDelimitedStream boundaryDelimitedStream =
	new BoundaryDelimitedStream(pushbackInStream,
	boundary, 1024);

	this.streams = new MultipartAttachmentStreams(boundaryDelimitedStream);
	}

	return this.streams;
	}

	public String[] getAllContentIDs() {
	Set keys = getContentIDSet();
	return (String[]) keys.toArray(new String[keys.size()]);
	}

	public Set getContentIDSet() {
	DataHandler dataHandler;
	while (!noStreams & true) {
	dataHandler = this.getNextPartDataHandler();
	if (dataHandler == null) {
	break;
	}
	}
	return attachmentsMap.keySet();
	}

	/**
	* endOfStreamReached will be set to true if the message ended in MIME Style
	* having "--" suffix with the last mime boundary
	*
	* @param value
	*/
	protected void setEndOfStream(boolean value) {
	this.endOfStreamReached = value;
	}

	/**
	* @return the Next valid MIME part + store the Part in the Parts List
	* @throws OMException throw if content id is null or if two MIME parts contain the
	* same content-ID & the exceptions throws by getPart()
	*/
	private DataHandler getNextPartDataHandler() throws OMException {
	if (endOfStreamReached)
	{
	return null;
	}
	Part nextPart;
	nextPart = getPart();
	if (nextPart==null)
	{
	return null;
	} else
	try {
	if (nextPart.getSize()>0) {
	String partContentID;
	try {
	partContentID = nextPart.getContentID();

	if (partContentID == null & partIndex == 1) {
	String id = "firstPart_"+UUIDGenerator.getUUID();
	attachmentsMap.put(id, nextPart);
	firstPartId = id;
	return nextPart.getDataHandler();
	}
	if (partContentID == null) {
	throw new OMException(
	"Part content ID cannot be blank for non root MIME parts");
	}
	if ((partContentID.indexOf("<") > -1)
	& (partContentID.indexOf(">") > -1)) {
	partContentID = partContentID.substring(1, (partContentID
	.length() - 1));

	} else if (partIndex == 1) {
	firstPartId = partContentID;
	}
	if (attachmentsMap.containsKey(partContentID)) {
	throw new OMException(
	"Two MIME parts with the same Content-ID not allowed.");
	}
	attachmentsMap.put(partContentID, nextPart.getDataHandler());
	return nextPart.getDataHandler();
	} catch (MessagingException e) {
	throw new OMException("Error reading Content-ID from the Part."
	+ e);
	}
	} // This will take care if stream ended without having MIME
	// message terminator
	else {
	return null;
	}
	} catch (MessagingException e) {
	throw new OMException(e);
	}
	}

	/**
	* @return This will return the next available MIME part in the stream.
	* @throws OMException if Stream ends while reading the next part...
	*/
	private Part getPart() throws OMException {

	if (streamsRequested) {
	throw new IllegalStateException("The attachments stream can only be accessed once; either by using the IncomingAttachmentStreams class or by getting a collection of AttachmentPart objects. They cannot both be called within the life time of the same service request.");
	}

	partsRequested = true;

	Part part;

	try {
	if (fileCacheEnable) {
	try {
	MIMEBodyPartInputStream partStream;
	byte[] buffer = new byte[fileStorageThreshold];
	partStream = new MIMEBodyPartInputStream(pushbackInStream,
	boundary, this);
	int count = 0;
	int value;
	// Make sure not to modify this to a Short Circuit "&". If
	// removed a byte will be lost
	while (count != fileStorageThreshold
	&& (!partStream.getBoundaryStatus())) {
	value = partStream.read();
	buffer[count] = (byte) value;
	count++;
	}
	if (count == fileStorageThreshold) {
	PushbackFilePartInputStream filePartStream = new PushbackFilePartInputStream(
	partStream, buffer);
	part = new PartOnFile(filePartStream, attachmentRepoDir);
	} else {
	ByteArrayInputStream byteArrayInStream = new ByteArrayInputStream(
	buffer, 0, count - 1);
	part = new PartOnMemory(byteArrayInStream);
	}
	} catch (Exception e) {
	throw new OMException("Error creating temporary File.", e);
	}
	} else {
	MIMEBodyPartInputStream partStream;
	partStream = new MIMEBodyPartInputStream(pushbackInStream,
	boundary, this);
	part = new PartOnMemory(partStream);
	}

	} catch (MessagingException e) {
	throw new OMException(e);
	}
	partIndex++;
	return part;
	}
	}