/*
* Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package com.sun.xml.internal.ws.encoding;
import com.sun.istack.internal.NotNull;
import com.sun.istack.internal.Nullable;
import com.sun.xml.internal.messaging.saaj.packaging.mime.MessagingException;
import com.sun.xml.internal.messaging.saaj.packaging.mime.internet.ContentType;
import com.sun.xml.internal.messaging.saaj.packaging.mime.internet.InternetHeaders;
import com.sun.xml.internal.messaging.saaj.packaging.mime.internet.ParseException;
import com.sun.xml.internal.ws.message.stream.StreamAttachment;
import com.sun.xml.internal.ws.util.ASCIIUtility;
import com.sun.xml.internal.ws.util.ByteArrayBuffer;
import javax.xml.ws.WebServiceException;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.BitSet;
import java.util.HashMap;
import java.util.Map;
/**
* Parses Mime multipart message into primary part and attachment parts. It
* parses the stream lazily as and when required.
*
* TODO need a list to keep all the attachments so that even if Content-Id is
* not there it is accounted
*
* @author Vivek Pandey
* @author Jitendra Kotamraju
*/
public final class MimeMultipartParser {
private final InputStream in;
private final String start;
private final byte[] boundaryBytes;
private final BitSet lastPartFound = new BitSet(1);
// current stream position, set to -1 on EOF
private int b = 0;
private final int[] bcs = new int[256];
private int[] gss;
private static final int BUFFER_SIZE = 4096;
private byte[] buffer = new byte[BUFFER_SIZE];
private byte[] prevBuffer = new byte[BUFFER_SIZE];
private boolean firstPart = true;
private final Map<String, StreamAttachment> attachments = new HashMap<String, StreamAttachment>();
private StreamAttachment root;
private int cidCounter = 0;
public MimeMultipartParser(InputStream in, String contentType) {
try {
ContentType ct = new ContentType(contentType);
String boundary = ct.getParameter("boundary");
if (boundary == null || boundary.equals("")) {
throw new WebServiceException("MIME boundary parameter not found" + contentType);
}
String bnd = "--" + boundary;
boundaryBytes = ASCIIUtility.getBytes(bnd);
start = ct.getParameter("start");
} catch (ParseException e) {
throw new WebServiceException(e);
}
//InputStream MUST support mark()
if (!in.markSupported()) {
this.in = new BufferedInputStream(in);
} else {
this.in = in;
}
}
/**
* Parses the stream and returns the root part. If start parameter is
* present in Content-Type, it is used to determine the root part, otherwise
* root part is the first part.
*
* @return StreamAttachment for root part
* null if root part cannot be found
*
*/
public @Nullable StreamAttachment getRootPart() {
if (root != null) {
return root;
}
while(!lastBodyPartFound() && (b != -1) && root == null) {
getNextPart();
}
return root;
}
/**
* Parses the entire stream and returns all MIME parts except root MIME part.
*
* @return Map<String, StreamAttachment> for all attachment parts
*/
public @NotNull Map<String, StreamAttachment> getAttachmentParts() {
while(!lastBodyPartFound() && (b != -1)) {
getNextPart();
}
return attachments;
}
/**
* This method can be called to get a matching MIME attachment part for the
* given contentId. It parses the stream until it finds a matching part.
*
* @return StreamAttachment attachment for contentId
* null if there is no attachment for contentId
*/
public @Nullable StreamAttachment getAttachmentPart(String contentId) throws IOException {
//first see if this attachment is already parsed, if so return it
StreamAttachment streamAttach = attachments.get(contentId);
if (streamAttach != null) {
return streamAttach;
}
//else parse the MIME parts till we get what we want
while (!lastBodyPartFound() && (b != -1)) {
streamAttach = getNextPart();
String newContentId = streamAttach.getContentId();
if (newContentId != null && newContentId.equals(contentId)){
return streamAttach;
}
}
return null; // Attachment is not found
}
/**
* Parses the stream and returns next available MIME part. This shouldn't
* be called if there are no MIME parts in the stream. Attachment
* part(not root part) is cached in the {@link Map}<{@link String},{@link StreamAttachment}>
* before returning the MIME part. It also finds the root part of the MIME
* package and assigns root variable.
*
* @return StreamAttachment next available MIME part
*
*/
private StreamAttachment getNextPart() {
assert !lastBodyPartFound();
try {
if (firstPart) {
compileBoundaryPattern();
// skip the first boundary of the MIME package
if (!skipPreamble()) {
throw new WebServiceException("Missing Start Boundary, or boundary does not start on a new line");
}
}
InternetHeaders ih = new InternetHeaders(in);
String[] contentTypes = ih.getHeader("content-type");
String contentType = (contentTypes != null) ? contentTypes[0] : "application/octet-stream";
String [] contentIds = ih.getHeader("content-id");
String mimeContentId = (contentIds != null) ? contentIds[0] : null;
String contentId = mimeContentId;
if(mimeContentId!=null && mimeContentId.length()>2) {
if(contentId.charAt(0)=='<') contentId=mimeContentId.substring(1,mimeContentId.length()-1);
}
ByteArrayBuffer bos = new ByteArrayBuffer();
b = readBody(bos);
StreamAttachment as = new StreamAttachment(bos, contentId, contentType);
if (start == null && firstPart) {
root = as; // Taking first part as root part
} else if (mimeContentId != null && start != null && start.equals(mimeContentId)) {
root = as; // root part as identified by start parameter
} else if (contentId != null) {
attachments.put(contentId, as); // Attachment part
} else {
++cidCounter;
attachments.put(""+cidCounter, as);
}
firstPart = false;
return as;
} catch(IOException ioe) {
throw new WebServiceException(ioe);
} catch(MessagingException me) {
throw new WebServiceException(me);
}
}
private int readBody(ByteArrayBuffer baos) throws IOException {
if (!findMimeBody(baos)) {
//TODO: i18n
throw new WebServiceException("Missing boundary delimitier ");
}
return b;
}
private boolean findMimeBody(ByteArrayBuffer out) throws IOException {
int i;
int l = boundaryBytes.length;
int lx = l - 1;
int bufferLength;
int s = 0;
byte[] tmp;
boolean first = true;
BitSet eof = new BitSet(1);
while (true) {
in.mark(l);
if (!first) {
tmp = prevBuffer;
prevBuffer = buffer;
buffer = tmp;
}
bufferLength = readNext(in, l, eof);
if (bufferLength == -1) {
b = -1;
if ((s == l)) {
out.write(prevBuffer, 0, s);
}
return true;
}
if (bufferLength < l) {
out.write(buffer, 0, bufferLength);
b = -1;
return true;
}
for (i = lx; i >= 0; i--) {
if (buffer[i] != boundaryBytes[i]) {
break;
}
}
if (i < 0) {
if (s > 0) {
// so if s == 1 : it must be an LF
// if s == 2 : it must be a CR LF
if (s <= 2) {
String crlf = new String(prevBuffer, 0, s);
if (!"\n".equals(crlf) && !"\r\n".equals(crlf)) {
throw new WebServiceException(
"Boundary characters encountered in part Body " +
"without a preceeding CRLF");
}
} else if (s > 2) {
if ((prevBuffer[s - 2] == '\r') && (prevBuffer[s - 1] == '\n')) {
out.write(prevBuffer, 0, s - 2);
} else if (prevBuffer[s - 1] == '\n') {
out.write(prevBuffer, 0, s - 1);
} else {
throw new WebServiceException(
"Boundary characters encountered in part Body " +
"without a preceeding CRLF");
}
}
}
// found the boundary, skip *LWSP-char and CRLF
if (!skipLWSPAndCRLF(in)) {
//throw new Exception(
// "Boundary does not terminate with CRLF");
}
return true;
}
if ((s > 0)) {
if (prevBuffer[s - 1] == (byte) 13) {
// if buffer[0] == (byte)10
if (buffer[0] == (byte) 10) {
int j;
for (j = lx - 1; j > 0; j--) {
if (buffer[j + 1] != boundaryBytes[j]) {
break;
}
}
if (j == 0) {
// matched the boundaryBytes excluding the last char of the boundaryBytes
// so dont write the CR into stream
out.write(prevBuffer, 0, s - 1);
} else {
out.write(prevBuffer, 0, s);
}
} else {
out.write(prevBuffer, 0, s);
}
} else {
out.write(prevBuffer, 0, s);
}
}
s = Math.max(i + 1 - bcs[buffer[i] & 0x7f], gss[i]);
in.reset();
in.skip(s);
if (first) {
first = false;
}
}
}
private boolean lastBodyPartFound() {
return lastPartFound.get(0);
}
private void compileBoundaryPattern() {
int l = boundaryBytes.length;
int i;
int j;
// Copied from J2SE 1.4 regex code
// java.util.regex.Pattern.java
// Initialise Bad Character Shift table
for (i = 0; i < l; i++) {
bcs[boundaryBytes[i]] = i + 1;
}
// Initialise Good Suffix Shift table
gss = new int[l];
NEXT:
for (i = l; i > 0; i--) {
// j is the beginning index of suffix being considered
for (j = l - 1; j >= i; j--) {
// Testing for good suffix
if (boundaryBytes[j] == boundaryBytes[j - i]) {
// boundaryBytes[j..len] is a good suffix
gss[j - 1] = i;
} else {
// No match. The array has already been
// filled up with correct values before.
continue NEXT;
}
}
while (j > 0) {
gss[--j] = i;
}
}
gss[l - 1] = 1;
}
private boolean skipPreamble() throws IOException {
if (!findBoundary()) {
return false;
}
if (lastPartFound.get(0)) {
throw new WebServiceException("Found closing boundary delimiter while trying to skip preamble");
}
return true;
}
private boolean findBoundary() throws IOException {
int i;
int l = boundaryBytes.length;
int lx = l - 1;
BitSet eof = new BitSet(1);
while (true) {
in.mark(l);
readNext(in, l, eof);
if (eof.get(0)) {
// End of stream
return false;
}
for (i = lx; i >= 0; i--) {
if (buffer[i] != boundaryBytes[i]) {
break;
}
}
if (i < 0) {
// found the boundary, skip *LWSP-char and CRLF
if (!skipLWSPAndCRLF(in)) {
throw new WebServiceException("Boundary does not terminate with CRLF");
}
return true;
}
int s = Math.max(i + 1 - bcs[buffer[i] & 0x7f], gss[i]);
in.reset();
in.skip(s);
}
}
private boolean skipLWSPAndCRLF(InputStream is) throws IOException {
b = is.read();
//looks like old impl allowed just a \n as well
if (b == '\n') {
return true;
}
if (b == '\r') {
b = is.read();
if (b == '\n') {
return true;
} else {
throw new WebServiceException(
"transport padding after a Mime Boundary should end in a CRLF, found CR only");
}
}
if (b == '-') {
b = is.read();
if (b != '-') {
throw new WebServiceException(
"Unexpected singular '-' character after Mime Boundary");
} else {
lastPartFound.flip(0);
// read the next char
b = is.read();
}
}
while ((b != -1) && ((b == ' ') || (b == '\t'))) {
b = is.read();
if (b == '\r') {
b = is.read();
if (b == '\n') {
return true;
}
}
}
if (b == -1) {
// the last boundary need not have CRLF
if (!lastPartFound.get(0)) {
throw new WebServiceException(
"End of Multipart Stream before encountering closing boundary delimiter");
}
return true;
}
return false;
}
private int readNext(InputStream is, int patternLength, BitSet eof) throws IOException {
int bufferLength = is.read(buffer, 0, patternLength);
if (bufferLength == -1) {
eof.flip(0);
} else if (bufferLength < patternLength) {
//repeatedly read patternLength - bufferLength
int temp ;
int i = bufferLength;
for (; i < patternLength; i++) {
temp = is.read();
if (temp == -1) {
eof.flip(0);
break;
}
buffer[i] = (byte) temp;
}
bufferLength = i;
}
return bufferLength;
}
}