src/main/java/org/apache/james/mime4j/MimeEntity.java

   1 package org.apache.james.mime4j;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5
   6 import org.apache.james.mime4j.decoder.Base64InputStream;
   7 import org.apache.james.mime4j.decoder.QuotedPrintableInputStream;
   8 import org.apache.james.mime4j.util.MimeUtil;
   9
  10 public class MimeEntity extends AbstractEntity {
  11
  12     /**
  13      * Internal state, not exposed.
  14      */
  15     private static final int T_IN_BODYPART = -2;
  16     /**
  17      * Internal state, not exposed.
  18      */
  19     private static final int T_IN_MESSAGE = -3;
  20
  21     private final RootInputStream rootStream;
  22     private final InputStream rawStream;
  23     private final InputBuffer inbuffer;
  24
  25     private int recursionMode;
  26     private MimeBoundaryInputStream mimeStream;
  27     private BufferingInputStreamAdaptor dataStream;
  28     private boolean skipHeader;
  29
  30     private byte[] tmpbuf;
  31
  32     public MimeEntity(
  33             RootInputStream rootStream,
  34             InputStream rawStream,
  35             InputBuffer inbuffer,
  36             BodyDescriptor parent,
  37             int startState,
  38             int endState,
  39             boolean maximalBodyDescriptor,
  40             boolean strictParsing) {
  41         super(parent, startState, endState, maximalBodyDescriptor, strictParsing);
  42         this.rootStream = rootStream;
  43         this.inbuffer = inbuffer;
  44         this.rawStream = rawStream;
  45         this.dataStream = new BufferingInputStreamAdaptor(rawStream);
  46         this.skipHeader = false;
  47     }
  48
  49     public MimeEntity(
  50             RootInputStream rootStream,
  51             InputStream rawStream,
  52             InputBuffer inbuffer,
  53             BodyDescriptor parent,
  54             int startState,
  55             int endState) {
  56         this(rootStream, rawStream, inbuffer, parent, startState, endState, false, false);
  57     }
  58
  59     public int getRecursionMode() {
  60         return recursionMode;
  61     }
  62
  63     public void setRecursionMode(int recursionMode) {
  64         this.recursionMode = recursionMode;
  65     }
  66
  67     public void skipHeader(String contentType) {
  68         if (state != EntityStates.T_START_MESSAGE) {
  69             throw new IllegalStateException("Invalid state: " + stateToString(state));
  70         }
  71         skipHeader = true;
  72         body.addField("Content-Type", contentType);
  73     }
  74
  75     protected int getLineNumber() {
  76         return rootStream.getLineNumber();
  77     }
  78
  79     protected BufferingInputStream getDataStream() {
  80         return dataStream;
  81     }
  82
  83     public EntityStateMachine advance() throws IOException, MimeException {
  84         switch (state) {
  85         case EntityStates.T_START_MESSAGE:
  86             if (skipHeader) {
  87                 state = EntityStates.T_END_HEADER;
  88             } else {
  89                 state = EntityStates.T_START_HEADER;
  90             }
  91             break;
  92         case EntityStates.T_START_BODYPART:
  93             state = EntityStates.T_START_HEADER;
  94             break;
  95         case EntityStates.T_START_HEADER:
  96         case EntityStates.T_FIELD:
  97             state = parseField() ? EntityStates.T_FIELD : EntityStates.T_END_HEADER;
  98             break;
  99         case EntityStates.T_END_HEADER:
 100             String mimeType = body.getMimeType();
 101             if (recursionMode == RecursionMode.M_FLAT) {
 102                 state = EntityStates.T_BODY;
 103             } else if (MimeUtil.isMultipart(mimeType)) {
 104                 state = EntityStates.T_START_MULTIPART;
 105                 clearMimeStream();
 106             } else if (recursionMode != RecursionMode.M_NO_RECURSE
 107                     && MimeUtil.isMessage(mimeType)) {
 108                 state = T_IN_MESSAGE;
 109                 return nextMessage();
 110             } else {
 111                 state = EntityStates.T_BODY;
 112             }
 113             break;
 114         case EntityStates.T_START_MULTIPART:
 115             if (dataStream.isUsed()) {
 116                 advanceToBoundary();
 117                 state = EntityStates.T_END_MULTIPART;
 118             } else {
 119                 createMimeStream();
 120                 state = EntityStates.T_PREAMBLE;
 121             }
 122             break;
 123         case EntityStates.T_PREAMBLE:
 124             advanceToBoundary();
 125             if (mimeStream.isLastPart()) {
 126                 clearMimeStream();
 127                 state = EntityStates.T_END_MULTIPART;
 128             } else {
 129                 createMimeStream();
 130                 state = T_IN_BODYPART;
 131                 return nextMimeEntity();
 132             }
 133             break;
 134         case T_IN_BODYPART:
 135             advanceToBoundary();
 136             if (mimeStream.eof() && !mimeStream.isLastPart()) {
 137                 monitor(Event.MIME_BODY_PREMATURE_END);
 138             } else {
 139                 if (!mimeStream.isLastPart()) {
 140                     createMimeStream();
 141                     state = T_IN_BODYPART;
 142                     return nextMimeEntity();
 143                 }
 144             }
 145             clearMimeStream();
 146             state = EntityStates.T_EPILOGUE;
 147             break;
 148         case EntityStates.T_EPILOGUE:
 149             state = EntityStates.T_END_MULTIPART;
 150             break;
 151         case EntityStates.T_BODY:
 152         case EntityStates.T_END_MULTIPART:
 153         case T_IN_MESSAGE:
 154             state = endState;
 155             break;
 156         default:
 157             if (state == endState) {
 158                 state = EntityStates.T_END_OF_STREAM;
 159                 break;
 160             }
 161             throw new IllegalStateException("Invalid state: " + stateToString(state));
 162         }
 163         return null;
 164     }
 165
 166     private void createMimeStream() throws IOException {
 167         mimeStream = new MimeBoundaryInputStream(inbuffer, body.getBoundary());
 168         dataStream = new BufferingInputStreamAdaptor(mimeStream);
 169         // If multipart message is embedded into another multipart message
 170         // make sure to reset parent's mime stream
 171         if (rawStream instanceof BufferingInputStream) {
 172             ((BufferingInputStream) rawStream).reset();
 173         }
 174     }
 175
 176     private void clearMimeStream() {
 177         mimeStream = null;
 178         dataStream = new BufferingInputStreamAdaptor(rawStream);
 179     }
 180
 181     private void advanceToBoundary() throws IOException {
 182         if (!dataStream.eof()) {
 183             if (tmpbuf == null) {
 184                 tmpbuf = new byte[2048];
 185             }
 186             while (dataStream.read(tmpbuf)!= -1) {
 187             }
 188         }
 189     }
 190
 191     private EntityStateMachine nextMessage() {
 192         String transferEncoding = body.getTransferEncoding();
 193         InputStream instream;
 194         InputBuffer buffer;
 195         if (MimeUtil.isBase64Encoding(transferEncoding)) {
 196             log.debug("base64 encoded message/rfc822 detected");
 197             instream = new Base64InputStream(dataStream);
 198             buffer = new InputBuffer(instream, 4 * 1024);
 199         } else if (MimeUtil.isQuotedPrintableEncoded(transferEncoding)) {
 200             log.debug("quoted-printable encoded message/rfc822 detected");
 201             instream = new QuotedPrintableInputStream(dataStream);
 202             buffer = new InputBuffer(instream, 4 * 1024);
 203         } else {
 204             instream = dataStream;
 205             buffer = inbuffer;
 206         }
 207
 208         if (recursionMode == RecursionMode.M_RAW) {
 209             RawEntity message = new RawEntity(instream);
 210             return message;
 211         } else {
 212             MimeEntity message = new MimeEntity(
 213                     rootStream,
 214                     instream,
 215                     buffer,
 216                     body,
 217                     EntityStates.T_START_MESSAGE,
 218                     EntityStates.T_END_MESSAGE,
 219                     maximalBodyDescriptor,
 220                     strictParsing);
 221             message.setRecursionMode(recursionMode);
 222             return message;
 223         }
 224     }
 225
 226     private EntityStateMachine nextMimeEntity() {
 227         if (recursionMode == RecursionMode.M_RAW) {
 228             RawEntity message = new RawEntity(mimeStream);
 229             return message;
 230         } else {
 231             MimeEntity mimeentity = new MimeEntity(
 232                     rootStream,
 233                     mimeStream,
 234                     inbuffer,
 235                     body,
 236                     EntityStates.T_START_BODYPART,
 237                     EntityStates.T_END_BODYPART,
 238                     maximalBodyDescriptor,
 239                     strictParsing);
 240             mimeentity.setRecursionMode(recursionMode);
 241             return mimeentity;
 242         }
 243     }
 244
 245     public InputStream getContentStream() {
 246         switch (state) {
 247         case EntityStates.T_START_MULTIPART:
 248         case EntityStates.T_PREAMBLE:
 249         case EntityStates.T_EPILOGUE:
 250         case EntityStates.T_BODY:
 251             return this.dataStream;
 252         default:
 253             throw new IllegalStateException("Invalid state: " + stateToString(state));
 254         }
 255     }
 256
 257 }