Java tutorial
/* * Copyright 2001-2004 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.axis.attachments; import org.apache.axis.components.logger.LogFactory; import org.apache.axis.utils.Messages; import org.apache.commons.logging.Log; import java.io.IOException; /** * This class takes the input stream and turns it multiple streams. DIME version 0 format <pre> 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ --- | VERSION |B|E|C| TYPE_T| OPT_T | OPTIONS_LENGTH | A +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | ID_LENGTH | TYPE_LENGTH | Always present 12 bytes +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ even on chunked data. | DATA_LENGTH | V +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ --- | / / OPTIONS + PADDING / / (absent for version 0) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | / / ID + PADDING / / | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | / / TYPE + PADDING / / | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | / / DATA + PADDING / / | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ </pre> * This implementation of input stream does not support marking operations. * * @author Rick Rineholt */ public class DimeDelimitedInputStream extends java.io.FilterInputStream { protected static Log log = LogFactory.getLog(DimeDelimitedInputStream.class.getName()); java.io.InputStream is = null; //The source input stream. volatile boolean closed = true; //The stream has been closed. boolean theEnd = false; //There are no more streams left. boolean moreChunks = false; //More chunks are a coming! boolean MB = false; //First part of the stream. MUST be SOAP. boolean ME = false; //Last part of stream. DimeTypeNameFormat tnf = null; String type = null; String id = null; long recordLength = 0L; //length of the record. long bytesRead = 0; //How many bytes of the record have been read. int dataPadLength = 0; //How many pad bytes there are. private static byte[] trash = new byte[4]; protected int streamNo = 0; protected IOException streamInError = null; protected static int streamCount = 0; //number of streams produced. protected static synchronized int newStreamNo() { log.debug(Messages.getMessage("streamNo", "" + (streamCount + 1))); return ++streamCount; } static boolean isDebugEnabled = false; /** * Gets the next stream. From the previous using new buffer reading size. * * @return the dime delmited stream, null if there are no more streams * @throws IOException if there was an error loading the data for the next * stream */ synchronized DimeDelimitedInputStream getNextStream() throws IOException { if (null != streamInError) throw streamInError; if (theEnd) return null; if (bytesRead < recordLength || moreChunks) //Stream must be read in succession throw new RuntimeException(Messages.getMessage("attach.dimeReadFullyError")); dataPadLength -= readPad(dataPadLength); //Create an new dime stream that comes after this one. return new DimeDelimitedInputStream(this.is); } /** * Create a new dime stream. * * @param is the <code>InputStream</code> to wrap * @throws IOException if anything goes wrong */ DimeDelimitedInputStream(java.io.InputStream is) throws IOException { super(null); //we handle everything so this is not necessary, don't won't to hang on to a reference. isDebugEnabled = log.isDebugEnabled(); streamNo = newStreamNo(); closed = false; this.is = is; readHeader(false); } private final int readPad(final int size) throws IOException { if (0 == size) return 0; int read = readFromStream(trash, 0, size); if (size != read) { streamInError = new IOException(Messages.getMessage("attach.dimeNotPaddedCorrectly")); throw streamInError; } return read; } private final int readFromStream(final byte[] b) throws IOException { return readFromStream(b, 0, b.length); } private final int readFromStream(final byte[] b, final int start, final int length) throws IOException { if (length == 0) return 0; int br = 0; int brTotal = 0; do { try { br = is.read(b, brTotal + start, length - brTotal); } catch (IOException e) { streamInError = e; throw e; } if (br > 0) brTotal += br; } while (br > -1 && brTotal < length); return br > -1 ? brTotal : br; } /** * Get the id for this stream part. * @return the id; */ public String getContentId() { return id; } public DimeTypeNameFormat getDimeTypeNameFormat() { return tnf; } /** * Get the type, as read from the header. * * @return the type of this dime */ public String getType() { return type; } /** * Read from the DIME stream. * * @param b is the array to read into. * @param off is the offset * @return the number of bytes read. -1 if endof stream * @throws IOException if data could not be read from the stream */ public synchronized int read(byte[] b, final int off, final int len) throws IOException { if (closed) { dataPadLength -= readPad(dataPadLength); throw new IOException(Messages.getMessage("streamClosed")); } return _read(b, off, len); } protected int _read(byte[] b, final int off, final int len) throws IOException { if (len < 0) throw new IllegalArgumentException(Messages.getMessage("attach.readLengthError", "" + len)); if (off < 0) throw new IllegalArgumentException(Messages.getMessage("attach.readOffsetError", "" + off)); if (b == null) throw new IllegalArgumentException(Messages.getMessage("attach.readArrayNullError")); if (b.length < off + len) throw new IllegalArgumentException( Messages.getMessage("attach.readArraySizeError", "" + b.length, "" + len, "" + off)); if (null != streamInError) throw streamInError; if (0 == len) return 0; //quick. if (recordLength == 0 && bytesRead == 0 && !moreChunks) { ++bytesRead; //odd case no data to read -- give back 0 next time -1; if (ME) { finalClose(); } return 0; } if (bytesRead >= recordLength && !moreChunks) { dataPadLength -= readPad(dataPadLength); if (ME) { finalClose(); } return -1; } int totalbytesread = 0; int bytes2read = 0; do { if (bytesRead >= recordLength && moreChunks) readHeader(true); bytes2read = (int) Math.min(recordLength - bytesRead, (long) len - totalbytesread); bytes2read = (int) Math.min(recordLength - bytesRead, (long) len - totalbytesread); try { bytes2read = is.read(b, off + totalbytesread, bytes2read); } catch (IOException e) { streamInError = e; throw e; } if (0 < bytes2read) { totalbytesread += bytes2read; bytesRead += bytes2read; } } while (bytes2read > -1 && totalbytesread < len && (bytesRead < recordLength || moreChunks)); if (0 > bytes2read) { if (moreChunks) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError0")); throw streamInError; } if (bytesRead < recordLength) { streamInError = new IOException( Messages.getMessage("attach.DimeStreamError1", "" + (recordLength - bytesRead))); throw streamInError; } if (!ME) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError0")); throw streamInError; } //in theory the last chunk of data should also have been padded, but lets be tolerant of that. dataPadLength = 0; } else if (bytesRead >= recordLength) { //get rid of pading. try { dataPadLength -= readPad(dataPadLength); } catch (IOException e) { //in theory the last chunk of data should also have been padded, but lets be tolerant of that. if (!ME) throw e; else { dataPadLength = 0; streamInError = null; } } } if (bytesRead >= recordLength && ME) { finalClose(); } return totalbytesread >= 0 ? totalbytesread : -1; } void readHeader(boolean isChunk) throws IOException { bytesRead = 0; //How many bytes of the record have been read. if (isChunk) { if (!moreChunks) throw new RuntimeException(Messages.getMessage("attach.DimeStreamError2")); dataPadLength -= readPad(dataPadLength); //Just incase it was left over. } byte[] header = new byte[12]; if (header.length != readFromStream(header)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError3", "" + header.length)); throw streamInError; } //VERSION byte version = (byte) ((header[0] >>> 3) & 0x1f); if (version > DimeMultiPart.CURRENT_VERSION) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError4", "" + version, "" + DimeMultiPart.CURRENT_VERSION)); throw streamInError; } //B, E, C MB = 0 != (0x4 & header[0]); ME = 0 != (0x2 & header[0]); moreChunks = 0 != (0x1 & header[0]); //TYPE_T if (!isChunk) tnf = DimeTypeNameFormat.parseByte((byte) ((header[1] >>> 4) & (byte) 0xf)); //OPTIONS_LENGTH int optionsLength = ((((int) header[2]) << 8) & 0xff00) | ((int) header[3]); //ID_LENGTH int idLength = ((((int) header[4]) << 8) & 0xff00) | ((int) header[5]); //TYPE_LENGTH int typeLength = ((((int) header[6]) << 8) & 0xff00) | ((int) header[7]); //DATA_LENGTH recordLength = ((((long) header[8]) << 24) & 0xff000000L) | ((((long) header[9]) << 16) & 0xff0000L) | ((((long) header[10]) << 8) & 0xff00L) | ((long) header[11] & 0xffL); //OPTIONS + PADDING if (0 != optionsLength) { byte[] optBytes = new byte[optionsLength]; if (optionsLength != readFromStream(optBytes)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError5", "" + optionsLength)); throw streamInError; } optBytes = null; //Yup throw it away, don't know anything about options. int pad = DimeBodyPart.dimePadding(optionsLength); if (pad != readFromStream(header, 0, pad)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError7")); throw streamInError; } } // ID + PADDING if (0 < idLength) { byte[] idBytes = new byte[idLength]; if (idLength != readFromStream(idBytes)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError8")); throw streamInError; } if (idLength != 0 && !isChunk) { id = new String(idBytes); } int pad = DimeBodyPart.dimePadding(idLength); if (pad != readFromStream(header, 0, pad)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError9")); throw streamInError; } } //TYPE + PADDING if (0 < typeLength) { byte[] typeBytes = new byte[typeLength]; if (typeLength != readFromStream(typeBytes)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError10")); throw streamInError; } if (typeLength != 0 && !isChunk) { type = new String(typeBytes); } int pad = DimeBodyPart.dimePadding(typeLength); if (pad != readFromStream(header, 0, pad)) { streamInError = new IOException(Messages.getMessage("attach.DimeStreamError11")); throw streamInError; } } log.debug("MB:" + MB + ", ME:" + ME + ", CF:" + moreChunks + "Option length:" + optionsLength + ", ID length:" + idLength + ", typeLength:" + typeLength + ", TYPE_T:" + tnf); log.debug("id:\"" + id + "\""); log.debug("type:\"" + type + "\""); log.debug("recordlength:\"" + recordLength + "\""); dataPadLength = DimeBodyPart.dimePadding(recordLength); } /** * Read from the delimited stream. * @param b is the array to read into. Read as much as possible * into the size of this array. * @return the number of bytes read. -1 if endof stream * @throws IOException if data could not be read from the stream */ public int read(byte[] b) throws IOException { return read(b, 0, b.length); } // fixme: this seems a bit inefficient /** * Read from the boundary delimited stream. * * @return the byte read, or -1 if endof stream * @throws IOException if there was an error reading the data */ public int read() throws IOException { byte[] b = new byte[1]; int read = read(b, 0, 1); if (read < 0) return -1; // fixme: should we also check for read != 1? return (b[0] & 0xff); // convert byte value to a positive int } /** * Closes the stream. * <p> * This will take care of flushing any remaining data to the strea. * <p> * Multiple calls to this method will result in the stream being closed once * and then all subsequent calls being ignored. * * @throws IOException if the stream could not be closed */ public void close() throws IOException { synchronized (this) { if (closed) return; closed = true; //mark it closed. } log.debug(Messages.getMessage("bStreamClosed", "" + streamNo)); if (bytesRead < recordLength || moreChunks) { //We need get this off the stream. //Easy way to flush through the stream; byte[] readrest = new byte[1024 * 16]; int bread = 0; do { bread = _read(readrest, 0, readrest.length);//should also close the orginal stream. } while (bread > -1); } dataPadLength -= readPad(dataPadLength); } // fixme: if mark is not supported, do we throw an exception here? /** * Mark the stream. * This is not supported. */ public void mark(int readlimit) {//do nothing } public void reset() throws IOException { streamInError = new IOException(Messages.getMessage("attach.bounday.mns")); throw streamInError; } public boolean markSupported() { return false; } public synchronized int available() throws IOException { if (null != streamInError) throw streamInError; int chunkAvail = (int) Math.min((long) Integer.MAX_VALUE, recordLength - bytesRead); int streamAvail = 0; try { streamAvail = is.available(); } catch (IOException e) { streamInError = e; throw e; } if (chunkAvail == 0 && moreChunks && (12 + dataPadLength) <= streamAvail) { dataPadLength -= readPad(dataPadLength); readHeader(true); return available(); } return Math.min(streamAvail, chunkAvail); } protected void finalClose() throws IOException { try { theEnd = true; if (null != is) is.close(); } finally { is = null; } } }