/****************************************************************
* 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.message;
import java.io.IOException;
import java.io.OutputStream;
import org.apache.james.mime4j.codec.CodecUtil;
import org.apache.james.mime4j.field.ContentTypeField;
import org.apache.james.mime4j.field.FieldName;
import org.apache.james.mime4j.parser.Field;
import org.apache.james.mime4j.util.ByteArrayBuffer;
import org.apache.james.mime4j.util.ByteSequence;
import org.apache.james.mime4j.util.ContentUtil;
import org.apache.james.mime4j.util.MimeUtil;
/**
* Writes a message (or a part of a message) to an output stream.
* <p>
* This class cannot be instantiated; instead the static instance
* {@link #DEFAULT} implements the default strategy for writing a message.
* <p>
* This class may be subclassed to implement custom strategies for writing
* messages.
*/
public class MessageWriter {
private static final byte[] CRLF = { '\r', '\n' };
private static final byte[] DASHES = { '-', '-' };
/**
* The default message writer.
*/
public static final MessageWriter DEFAULT = new MessageWriter();
/**
* Protected constructor prevents direct instantiation.
*/
protected MessageWriter() {
}
/**
* Write the specified <code>Body</code> to the specified
* <code>OutputStream</code>.
*
* @param body
* the <code>Body</code> to write.
* @param out
* the OutputStream to write to.
* @throws IOException
* if an I/O error occurs.
*/
public void writeBody(Body body, OutputStream out) throws IOException {
if (body instanceof Message) {
writeEntity((Message) body, out);
} else if (body instanceof Multipart) {
writeMultipart((Multipart) body, out);
} else if (body instanceof SingleBody) {
((SingleBody) body).writeTo(out);
} else
throw new IllegalArgumentException("Unsupported body class");
}
/**
* Write the specified <code>Entity</code> to the specified
* <code>OutputStream</code>.
*
* @param entity
* the <code>Entity</code> to write.
* @param out
* the OutputStream to write to.
* @throws IOException
* if an I/O error occurs.
*/
public void writeEntity(Entity entity, OutputStream out) throws IOException {
final Header header = entity.getHeader();
if (header == null)
throw new IllegalArgumentException("Missing header");
writeHeader(header, out);
final Body body = entity.getBody();
if (body == null)
throw new IllegalArgumentException("Missing body");
boolean binaryBody = body instanceof BinaryBody;
OutputStream encOut = encodeStream(out, entity
.getContentTransferEncoding(), binaryBody);
writeBody(body, encOut);
// close if wrapped (base64 or quoted-printable)
if (encOut != out)
encOut.close();
}
/**
* Write the specified <code>Multipart</code> to the specified
* <code>OutputStream</code>.
*
* @param multipart
* the <code>Multipart</code> to write.
* @param out
* the OutputStream to write to.
* @throws IOException
* if an I/O error occurs.
*/
public void writeMultipart(Multipart multipart, OutputStream out)
throws IOException {
ContentTypeField contentType = getContentType(multipart);
ByteSequence boundary = getBoundary(contentType);
writeBytes(multipart.getPreambleRaw(), out);
out.write(CRLF);
for (BodyPart bodyPart : multipart.getBodyParts()) {
out.write(DASHES);
writeBytes(boundary, out);
out.write(CRLF);
writeEntity(bodyPart, out);
out.write(CRLF);
}
out.write(DASHES);
writeBytes(boundary, out);
out.write(DASHES);
out.write(CRLF);
writeBytes(multipart.getEpilogueRaw(), out);
}
/**
* Write the specified <code>Header</code> to the specified
* <code>OutputStream</code>.
*
* @param header
* the <code>Header</code> to write.
* @param out
* the OutputStream to write to.
* @throws IOException
* if an I/O error occurs.
*/
public void writeHeader(Header header, OutputStream out) throws IOException {
for (Field field : header) {
writeBytes(field.getRaw(), out);
out.write(CRLF);
}
out.write(CRLF);
}
protected OutputStream encodeStream(OutputStream out, String encoding,
boolean binaryBody) throws IOException {
if (MimeUtil.isBase64Encoding(encoding)) {
return CodecUtil.wrapBase64(out);
} else if (MimeUtil.isQuotedPrintableEncoded(encoding)) {
return CodecUtil.wrapQuotedPrintable(out, binaryBody);
} else {
return out;
}
}
private ContentTypeField getContentType(Multipart multipart) {
Entity parent = multipart.getParent();
if (parent == null)
throw new IllegalArgumentException(
"Missing parent entity in multipart");
Header header = parent.getHeader();
if (header == null)
throw new IllegalArgumentException(
"Missing header in parent entity");
ContentTypeField contentType = (ContentTypeField) header
.getField(FieldName.CONTENT_TYPE);
if (contentType == null)
throw new IllegalArgumentException(
"Content-Type field not specified");
return contentType;
}
private ByteSequence getBoundary(ContentTypeField contentType) {
String boundary = contentType.getBoundary();
if (boundary == null)
throw new IllegalArgumentException(
"Multipart boundary not specified");
return ContentUtil.encode(boundary);
}
private void writeBytes(ByteSequence byteSequence, OutputStream out)
throws IOException {
if (byteSequence instanceof ByteArrayBuffer) {
ByteArrayBuffer bab = (ByteArrayBuffer) byteSequence;
out.write(bab.buffer(), 0, bab.length());
} else {
out.write(byteSequence.toByteArray());
}
}
}