core/src/main/java/org/apache/james/mime4j/stream/MimeTokenStream.java - james-mime4j - 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.james.mime4j.stream;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;
 import java.util.LinkedList;

 import org.apache.james.mime4j.Charsets;
 import org.apache.james.mime4j.MimeException;
 import org.apache.james.mime4j.codec.DecodeMonitor;
 import org.apache.james.mime4j.io.LineNumberInputStream;
 import org.apache.james.mime4j.util.CharsetUtil;

 /**
  * <p>
  * Parses MIME (or RFC822) message streams of bytes or characters.
  * The stream is converted into an event stream.
  * <p>
  * <p>
  * Typical usage:
  * </p>
  * <pre>
  *      MimeTokenStream stream = new MimeTokenStream();
  *      InputStream instream = new FileInputStream("mime.msg");
  *      try {
  *          stream.parse(instream);
  *          for (int state = stream.getState();
  *              state != MimeTokenStream.T_END_OF_STREAM;
  *              state = stream.next()) {
  *              switch (state) {
  *              case MimeTokenStream.T_BODY:
  *                  System.out.println("Body detected, contents = "
  *                  + stream.getInputStream() + ", header data = "
  *                  + stream.getBodyDescriptor());
  *                  break;
  *              case MimeTokenStream.T_FIELD:
  *                  System.out.println("Header field detected: "
  *                  + stream.getField());
  *                  break;
  *              case MimeTokenStream.T_START_MULTIPART:
  *                  System.out.println("Multipart message detexted,"
  *                  + " header data = "
  *                  + stream.getBodyDescriptor());
  *              ...
  *              }
  *          }
  *      } finally {
  *          instream.close();
  *      }
  * </pre>
  * <p>Instances of {@link MimeTokenStream} are reusable: Invoking the
  * method {@link #parse(InputStream)} resets the token streams internal
  * state. However, they are definitely <em>not</em> thread safe. If you
  * have a multi threaded application, then the suggested use is to have
  * one instance per thread.</p>
  */
 public class MimeTokenStream {

     private final MimeConfig config;
     private final DecodeMonitor monitor;
     private final FieldBuilder fieldBuilder;
     private final BodyDescriptorBuilder bodyDescBuilder;
     private final LinkedList<EntityStateMachine> entities = new LinkedList<EntityStateMachine>();

     private EntityState state = EntityState.T_END_OF_STREAM;
     private EntityStateMachine currentStateMachine;
     private RecursionMode recursionMode = RecursionMode.M_RECURSE;
     private MimeEntity rootentity;

     /**
      * Constructs a standard (lax) stream.
      * Optional validation events will be logged only.
      * Use {@link MimeConfig.Builder#setStrictParsing(boolean)} to turn on strict
      * parsing mode and pass the config object to
      * {@link MimeTokenStream#MimeTokenStream(MimeConfig)} to create
      * a stream that strictly validates the input.
      */
     public MimeTokenStream() {
         this(null);
     }

     public MimeTokenStream(final MimeConfig config) {
         this(config, null, null, null);
     }

     public MimeTokenStream(
             final MimeConfig config,
             final BodyDescriptorBuilder bodyDescBuilder) {
         this(config, null, null, bodyDescBuilder);
     }

     public MimeTokenStream(
             final MimeConfig config,
             final DecodeMonitor monitor,
             final BodyDescriptorBuilder bodyDescBuilder) {
         this(config, monitor, null, bodyDescBuilder);
     }

     public MimeTokenStream(
             final MimeConfig config,
             final DecodeMonitor monitor,
             final FieldBuilder fieldBuilder,
             final BodyDescriptorBuilder bodyDescBuilder) {
         super();
         this.config = config != null ? config : MimeConfig.DEFAULT;
         this.fieldBuilder = fieldBuilder != null ? fieldBuilder :
             new DefaultFieldBuilder(this.config.getMaxHeaderLen());
         this.monitor = monitor != null ? monitor :
             (this.config.isStrictParsing() ? DecodeMonitor.STRICT : DecodeMonitor.SILENT);
         this.bodyDescBuilder = bodyDescBuilder != null ? bodyDescBuilder :
             new FallbackBodyDescriptorBuilder();
     }

     /** Instructs the {@code MimeTokenStream} to parse the given streams contents.
      * If the {@code MimeTokenStream} has already been in use, resets the streams
      * internal state.
      */
     public void parse(InputStream stream) {
         doParse(stream, EntityState.T_START_MESSAGE);
     }

     /**
      * <p>Instructs the {@code MimeTokenStream} to parse the given content with
      * the content type. The message stream is assumed to have no message header
      * and is expected to begin with a message body. This can be the case when
      * the message content is transmitted using a different transport protocol
      * such as HTTP.</p>
      * <p>If the {@code MimeTokenStream} has already been in use, resets the
      * streams internal state.</p>
      * @return a parsed Field representing the input contentType
      */
     public Field parseHeadless(InputStream stream, String contentType) {
         if (contentType == null) {
             throw new IllegalArgumentException("Content type may not be null");
         }
         Field newContentType;
         try {
             RawField rawContentType = new RawField("Content-Type", contentType);
             newContentType = bodyDescBuilder.addField(rawContentType);
             if (newContentType == null) newContentType = rawContentType;
         } catch (MimeException ex) {
             // should never happen
             throw new IllegalArgumentException(ex.getMessage());
         }

         doParse(stream, EntityState.T_END_HEADER);
         try {
             next();
         } catch (IOException e) {
             // Should never happend: the first next after END_HEADER does not produce IO
             throw new IllegalStateException(e);
         } catch (MimeException e) {
             // This should never happen
             throw new IllegalStateException(e);
         }
         return newContentType;
     }

     private void doParse(InputStream stream, EntityState start) {
         if (config.isCountLineNumbers()) {
             LineNumberInputStream lnstream = new LineNumberInputStream(stream);
             rootentity = new MimeEntity(
                     lnstream,
                     lnstream,
                     config,
                     start,
                     EntityState.T_END_MESSAGE,
                     monitor,
                     fieldBuilder,
                     bodyDescBuilder);
         } else {
             rootentity = new MimeEntity(
                     null,
                     stream,
                     config,
                     start,
                     EntityState.T_END_MESSAGE,
                     monitor,
                     fieldBuilder,
                     bodyDescBuilder);
         }

         rootentity.setRecursionMode(recursionMode);
         currentStateMachine = rootentity;
         entities.clear();
         entities.add(currentStateMachine);
         state = currentStateMachine.getState();
     }

     /**
      * Determines if this parser is currently in raw mode.
      *
      * @return <code>true</code> if in raw mode, <code>false</code>
      *         otherwise.
      * @see #setRecursionMode(RecursionMode)
      */
     public boolean isRaw() {
         return recursionMode == RecursionMode.M_RAW;
     }

     /**
      * Gets the current recursion mode.
      * The recursion mode specifies the approach taken to parsing parts.
      * {@link RecursionMode#M_RAW}  mode does not parse the part at all.
      * {@link RecursionMode#M_RECURSE} mode recursively parses each mail
      * when an <code>message/rfc822</code> part is encountered;
      * {@link RecursionMode#M_NO_RECURSE} does not.
      * @return {@link RecursionMode#M_RECURSE}, {@link RecursionMode#M_RAW} or
      *   {@link RecursionMode#M_NO_RECURSE}
      */
     public RecursionMode getRecursionMode() {
         return recursionMode;
     }

     /**
      * Sets the current recursion.
      * The recursion mode specifies the approach taken to parsing parts.
      * {@link RecursionMode#M_RAW}  mode does not parse the part at all.
      * {@link RecursionMode#M_RECURSE} mode recursively parses each mail
      * when an <code>message/rfc822</code> part is encountered;
      * {@link RecursionMode#M_NO_RECURSE} does not.
      * @param mode {@link RecursionMode#M_RECURSE}, {@link RecursionMode#M_RAW} or
      *   {@link RecursionMode#M_NO_RECURSE}
      */
     public void setRecursionMode(RecursionMode mode) {
         recursionMode = mode;
         if (currentStateMachine != null) {
             currentStateMachine.setRecursionMode(mode);
         }
     }

     /**
      * Finishes the parsing and stops reading lines.
      * NOTE: No more lines will be parsed but the parser
      * will still trigger 'end' events to match previously
      * triggered 'start' events.
      */
     public void stop() {
         rootentity.stop();
     }

     /**
      * Returns the current state.
      */
     public EntityState getState() {
         return state;
     }

     /**
      * <p>
      * This method returns the raw entity, preamble, or epilogue contents.
      * </p>
      * <p>
      * This method is valid, if {@link #getState()} returns either of
      * {@link EntityState#T_RAW_ENTITY}, {@link EntityState#T_PREAMBLE}, or
      * {@link EntityState#T_EPILOGUE}.
      * </p>
      *
      * @return Data stream, depending on the current state.
      * @throws IllegalStateException {@link #getState()} returns an
      *   invalid value.
      */
     public InputStream getInputStream() {
         return currentStateMachine.getContentStream();
     }

     /**
      * <p>
      * This method returns a transfer decoded stream based on the MIME
      * fields with the standard defaults.
      * </p>
      * <p>
      * This method is valid, if {@link #getState()} returns either of
      * {@link EntityState#T_RAW_ENTITY}, {@link EntityState#T_PREAMBLE}, or
      * {@link EntityState#T_EPILOGUE}.
      * </p>
      *
      * @return Data stream, depending on the current state.
      * @throws IllegalStateException {@link #getState()} returns an
      *   invalid value.
      */
     public InputStream getDecodedInputStream() {
         return currentStateMachine.getDecodedContentStream();
     }

     /**
      * Gets a reader configured for the current body or body part.
      * The reader will return a transfer and charset decoded
      * stream of characters based on the MIME fields with the standard
      * defaults.
      * This is a conveniance method and relies on {@link #getInputStream()}.
      * Consult the javadoc for that method for known limitations.
      *
      * @return <code>Reader</code>, not null
      * @see #getInputStream
      * @throws IllegalStateException {@link #getState()} returns an
      *   invalid value
      * @throws UnsupportedEncodingException if there is no JVM support
      * for decoding the charset
      */
     public Reader getReader() throws UnsupportedEncodingException {
         final BodyDescriptor bodyDescriptor = getBodyDescriptor();
         final String mimeCharset = bodyDescriptor.getCharset();
         final Charset charset;
         if (mimeCharset == null || "".equals(mimeCharset)) {
             charset = Charsets.US_ASCII;
         } else {
             charset = CharsetUtil.lookup(mimeCharset);
             if (charset == null) {
                 throw new UnsupportedEncodingException(mimeCharset);
             }
         }
         final InputStream instream = getDecodedInputStream();
         return new InputStreamReader(instream, charset);
     }

     /**
      * <p>Gets a descriptor for the current entity.
      * This method is valid if {@link #getState()} returns:</p>
      * <ul>
      * <li>{@link EntityState#T_BODY}</li>
      * <li>{@link EntityState#T_START_MULTIPART}</li>
      * <li>{@link EntityState#T_EPILOGUE}</li>
      * <li>{@link EntityState#T_PREAMBLE}</li>
      * </ul>
      * @return <code>BodyDescriptor</code>, not nulls
      */
     public BodyDescriptor getBodyDescriptor() {
         return currentStateMachine.getBodyDescriptor();
     }

     /**
      * This method is valid, if {@link #getState()} returns {@link EntityState#T_FIELD}.
      * @return String with the fields raw contents.
      * @throws IllegalStateException {@link #getState()} returns another
      *   value than {@link EntityState#T_FIELD}.
      */
     public Field getField() {
         return currentStateMachine.getField();
     }

     /**
      * This method advances the token stream to the next token.
      * @throws IllegalStateException The method has been called, although
      *   {@link #getState()} was already {@link EntityState#T_END_OF_STREAM}.
      */
     public EntityState next() throws IOException, MimeException {
         if (state == EntityState.T_END_OF_STREAM  ||  currentStateMachine == null) {
             throw new IllegalStateException("No more tokens are available.");
         }
         while (currentStateMachine != null) {
             EntityStateMachine next = currentStateMachine.advance();
             if (next != null) {
                 entities.add(next);
                 currentStateMachine = next;
             }
             state = currentStateMachine.getState();
             if (state != EntityState.T_END_OF_STREAM) {
                 return state;
             }
             entities.removeLast();
             if (entities.isEmpty()) {
                 currentStateMachine = null;
             } else {
                 currentStateMachine = entities.getLast();
                 currentStateMachine.setRecursionMode(recursionMode);
             }
         }
         state = EntityState.T_END_OF_STREAM;
         return state;
     }

     /**
      * Renders a state as a string suitable for logging.
      * @param state
      * @return rendered as string, not null
      */
     public static String stateToString(EntityState state) {
         return MimeEntity.stateToString(state);
     }


     public MimeConfig getConfig() {
         return config;
     }
 }
	/****************************************************************
	* 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.james.mime4j.stream;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.Reader;
	import java.io.UnsupportedEncodingException;
	import java.nio.charset.Charset;
	import java.util.LinkedList;

	import org.apache.james.mime4j.Charsets;
	import org.apache.james.mime4j.MimeException;
	import org.apache.james.mime4j.codec.DecodeMonitor;
	import org.apache.james.mime4j.io.LineNumberInputStream;
	import org.apache.james.mime4j.util.CharsetUtil;

	/**
	* <p>
	* Parses MIME (or RFC822) message streams of bytes or characters.
	* The stream is converted into an event stream.
	* <p>
	* <p>
	* Typical usage:
	* </p>
	* <pre>
	* MimeTokenStream stream = new MimeTokenStream();
	* InputStream instream = new FileInputStream("mime.msg");
	* try {
	* stream.parse(instream);
	* for (int state = stream.getState();
	* state != MimeTokenStream.T_END_OF_STREAM;
	* state = stream.next()) {
	* switch (state) {
	* case MimeTokenStream.T_BODY:
	* System.out.println("Body detected, contents = "
	* + stream.getInputStream() + ", header data = "
	* + stream.getBodyDescriptor());
	* break;
	* case MimeTokenStream.T_FIELD:
	* System.out.println("Header field detected: "
	* + stream.getField());
	* break;
	* case MimeTokenStream.T_START_MULTIPART:
	* System.out.println("Multipart message detexted,"
	* + " header data = "
	* + stream.getBodyDescriptor());
	* ...
	* }
	* }
	* } finally {
	* instream.close();
	* }
	* </pre>
	* <p>Instances of {@link MimeTokenStream} are reusable: Invoking the
	* method {@link #parse(InputStream)} resets the token streams internal
	* state. However, they are definitely <em>not</em> thread safe. If you
	* have a multi threaded application, then the suggested use is to have
	* one instance per thread.</p>
	*/
	public class MimeTokenStream {

	private final MimeConfig config;
	private final DecodeMonitor monitor;
	private final FieldBuilder fieldBuilder;
	private final BodyDescriptorBuilder bodyDescBuilder;
	private final LinkedList<EntityStateMachine> entities = new LinkedList<EntityStateMachine>();

	private EntityState state = EntityState.T_END_OF_STREAM;
	private EntityStateMachine currentStateMachine;
	private RecursionMode recursionMode = RecursionMode.M_RECURSE;
	private MimeEntity rootentity;

	/**
	* Constructs a standard (lax) stream.
	* Optional validation events will be logged only.
	* Use {@link MimeConfig.Builder#setStrictParsing(boolean)} to turn on strict
	* parsing mode and pass the config object to
	* {@link MimeTokenStream#MimeTokenStream(MimeConfig)} to create
	* a stream that strictly validates the input.
	*/
	public MimeTokenStream() {
	this(null);
	}

	public MimeTokenStream(final MimeConfig config) {
	this(config, null, null, null);
	}

	public MimeTokenStream(
	final MimeConfig config,
	final BodyDescriptorBuilder bodyDescBuilder) {
	this(config, null, null, bodyDescBuilder);
	}

	public MimeTokenStream(
	final MimeConfig config,
	final DecodeMonitor monitor,
	final BodyDescriptorBuilder bodyDescBuilder) {
	this(config, monitor, null, bodyDescBuilder);
	}

	public MimeTokenStream(
	final MimeConfig config,
	final DecodeMonitor monitor,
	final FieldBuilder fieldBuilder,
	final BodyDescriptorBuilder bodyDescBuilder) {
	super();
	this.config = config != null ? config : MimeConfig.DEFAULT;
	this.fieldBuilder = fieldBuilder != null ? fieldBuilder :
	new DefaultFieldBuilder(this.config.getMaxHeaderLen());
	this.monitor = monitor != null ? monitor :
	(this.config.isStrictParsing() ? DecodeMonitor.STRICT : DecodeMonitor.SILENT);
	this.bodyDescBuilder = bodyDescBuilder != null ? bodyDescBuilder :
	new FallbackBodyDescriptorBuilder();
	}

	/** Instructs the {@code MimeTokenStream} to parse the given streams contents.
	* If the {@code MimeTokenStream} has already been in use, resets the streams
	* internal state.
	*/
	public void parse(InputStream stream) {
	doParse(stream, EntityState.T_START_MESSAGE);
	}

	/**
	* <p>Instructs the {@code MimeTokenStream} to parse the given content with
	* the content type. The message stream is assumed to have no message header
	* and is expected to begin with a message body. This can be the case when
	* the message content is transmitted using a different transport protocol
	* such as HTTP.</p>
	* <p>If the {@code MimeTokenStream} has already been in use, resets the
	* streams internal state.</p>
	* @return a parsed Field representing the input contentType
	*/
	public Field parseHeadless(InputStream stream, String contentType) {
	if (contentType == null) {
	throw new IllegalArgumentException("Content type may not be null");
	}
	Field newContentType;
	try {
	RawField rawContentType = new RawField("Content-Type", contentType);
	newContentType = bodyDescBuilder.addField(rawContentType);
	if (newContentType == null) newContentType = rawContentType;
	} catch (MimeException ex) {
	// should never happen
	throw new IllegalArgumentException(ex.getMessage());
	}

	doParse(stream, EntityState.T_END_HEADER);
	try {
	next();
	} catch (IOException e) {
	// Should never happend: the first next after END_HEADER does not produce IO
	throw new IllegalStateException(e);
	} catch (MimeException e) {
	// This should never happen
	throw new IllegalStateException(e);
	}
	return newContentType;
	}

	private void doParse(InputStream stream, EntityState start) {
	if (config.isCountLineNumbers()) {
	LineNumberInputStream lnstream = new LineNumberInputStream(stream);
	rootentity = new MimeEntity(
	lnstream,
	lnstream,
	config,
	start,
	EntityState.T_END_MESSAGE,
	monitor,
	fieldBuilder,
	bodyDescBuilder);
	} else {
	rootentity = new MimeEntity(
	null,
	stream,
	config,
	start,
	EntityState.T_END_MESSAGE,
	monitor,
	fieldBuilder,
	bodyDescBuilder);
	}

	rootentity.setRecursionMode(recursionMode);
	currentStateMachine = rootentity;
	entities.clear();
	entities.add(currentStateMachine);
	state = currentStateMachine.getState();
	}

	/**
	* Determines if this parser is currently in raw mode.
	*
	* @return <code>true</code> if in raw mode, <code>false</code>
	* otherwise.
	* @see #setRecursionMode(RecursionMode)
	*/
	public boolean isRaw() {
	return recursionMode == RecursionMode.M_RAW;
	}

	/**
	* Gets the current recursion mode.
	* The recursion mode specifies the approach taken to parsing parts.
	* {@link RecursionMode#M_RAW} mode does not parse the part at all.
	* {@link RecursionMode#M_RECURSE} mode recursively parses each mail
	* when an <code>message/rfc822</code> part is encountered;
	* {@link RecursionMode#M_NO_RECURSE} does not.
	* @return {@link RecursionMode#M_RECURSE}, {@link RecursionMode#M_RAW} or
	* {@link RecursionMode#M_NO_RECURSE}
	*/
	public RecursionMode getRecursionMode() {
	return recursionMode;
	}

	/**
	* Sets the current recursion.
	* The recursion mode specifies the approach taken to parsing parts.
	* {@link RecursionMode#M_RAW} mode does not parse the part at all.
	* {@link RecursionMode#M_RECURSE} mode recursively parses each mail
	* when an <code>message/rfc822</code> part is encountered;
	* {@link RecursionMode#M_NO_RECURSE} does not.
	* @param mode {@link RecursionMode#M_RECURSE}, {@link RecursionMode#M_RAW} or
	* {@link RecursionMode#M_NO_RECURSE}
	*/
	public void setRecursionMode(RecursionMode mode) {
	recursionMode = mode;
	if (currentStateMachine != null) {
	currentStateMachine.setRecursionMode(mode);
	}
	}

	/**
	* Finishes the parsing and stops reading lines.
	* NOTE: No more lines will be parsed but the parser
	* will still trigger 'end' events to match previously
	* triggered 'start' events.
	*/
	public void stop() {
	rootentity.stop();
	}

	/**
	* Returns the current state.
	*/
	public EntityState getState() {
	return state;
	}

	/**
	* <p>
	* This method returns the raw entity, preamble, or epilogue contents.
	* </p>
	* <p>
	* This method is valid, if {@link #getState()} returns either of
	* {@link EntityState#T_RAW_ENTITY}, {@link EntityState#T_PREAMBLE}, or
	* {@link EntityState#T_EPILOGUE}.
	* </p>
	*
	* @return Data stream, depending on the current state.
	* @throws IllegalStateException {@link #getState()} returns an
	* invalid value.
	*/
	public InputStream getInputStream() {
	return currentStateMachine.getContentStream();
	}

	/**
	* <p>
	* This method returns a transfer decoded stream based on the MIME
	* fields with the standard defaults.
	* </p>
	* <p>
	* This method is valid, if {@link #getState()} returns either of
	* {@link EntityState#T_RAW_ENTITY}, {@link EntityState#T_PREAMBLE}, or
	* {@link EntityState#T_EPILOGUE}.
	* </p>
	*
	* @return Data stream, depending on the current state.
	* @throws IllegalStateException {@link #getState()} returns an
	* invalid value.
	*/
	public InputStream getDecodedInputStream() {
	return currentStateMachine.getDecodedContentStream();
	}

	/**
	* Gets a reader configured for the current body or body part.
	* The reader will return a transfer and charset decoded
	* stream of characters based on the MIME fields with the standard
	* defaults.
	* This is a conveniance method and relies on {@link #getInputStream()}.
	* Consult the javadoc for that method for known limitations.
	*
	* @return <code>Reader</code>, not null
	* @see #getInputStream
	* @throws IllegalStateException {@link #getState()} returns an
	* invalid value
	* @throws UnsupportedEncodingException if there is no JVM support
	* for decoding the charset
	*/
	public Reader getReader() throws UnsupportedEncodingException {
	final BodyDescriptor bodyDescriptor = getBodyDescriptor();
	final String mimeCharset = bodyDescriptor.getCharset();
	final Charset charset;
	if (mimeCharset == null \|\| "".equals(mimeCharset)) {
	charset = Charsets.US_ASCII;
	} else {
	charset = CharsetUtil.lookup(mimeCharset);
	if (charset == null) {
	throw new UnsupportedEncodingException(mimeCharset);
	}
	}
	final InputStream instream = getDecodedInputStream();
	return new InputStreamReader(instream, charset);
	}

	/**
	* <p>Gets a descriptor for the current entity.
	* This method is valid if {@link #getState()} returns:</p>
	* <ul>
	* <li>{@link EntityState#T_BODY}</li>
	* <li>{@link EntityState#T_START_MULTIPART}</li>
	* <li>{@link EntityState#T_EPILOGUE}</li>
	* <li>{@link EntityState#T_PREAMBLE}</li>
	* </ul>
	* @return <code>BodyDescriptor</code>, not nulls
	*/
	public BodyDescriptor getBodyDescriptor() {
	return currentStateMachine.getBodyDescriptor();
	}

	/**
	* This method is valid, if {@link #getState()} returns {@link EntityState#T_FIELD}.
	* @return String with the fields raw contents.
	* @throws IllegalStateException {@link #getState()} returns another
	* value than {@link EntityState#T_FIELD}.
	*/
	public Field getField() {
	return currentStateMachine.getField();
	}

	/**
	* This method advances the token stream to the next token.
	* @throws IllegalStateException The method has been called, although
	* {@link #getState()} was already {@link EntityState#T_END_OF_STREAM}.
	*/
	public EntityState next() throws IOException, MimeException {
	if (state == EntityState.T_END_OF_STREAM \|\| currentStateMachine == null) {
	throw new IllegalStateException("No more tokens are available.");
	}
	while (currentStateMachine != null) {
	EntityStateMachine next = currentStateMachine.advance();
	if (next != null) {
	entities.add(next);
	currentStateMachine = next;
	}
	state = currentStateMachine.getState();
	if (state != EntityState.T_END_OF_STREAM) {
	return state;
	}
	entities.removeLast();
	if (entities.isEmpty()) {
	currentStateMachine = null;
	} else {
	currentStateMachine = entities.getLast();
	currentStateMachine.setRecursionMode(recursionMode);
	}
	}
	state = EntityState.T_END_OF_STREAM;
	return state;
	}

	/**
	* Renders a state as a string suitable for logging.
	* @param state
	* @return rendered as string, not null
	*/
	public static String stateToString(EntityState state) {
	return MimeEntity.stateToString(state);
	}


	public MimeConfig getConfig() {
	return config;
	}
	}