* A wrapper around another {@link Storage} that also maintains a reference * counter. The inner storage gets deleted only if the reference counter reaches * zero. *
** Reference counting is used to delete the storage when it is no longer needed. * So, any users of this class should note: *
*-
*
- The reference count is set up one on construction. In all other cases, * {@link #addReference()} should be called when the storage is shared. *
- The caller of {@link #addReference()} should ensure that * {@link #delete()} is called once and only once. *
- Sharing the {@link Storage} instance passed into * {@link #MultiReferenceStorage(Storage)} may lead to miscounting and premature * deletion *
MultiReferenceStorage instance for the given
* back-end. The reference counter is initially set to one so the caller
* does not have to call {@link #addReference()} after this constructor.
*
* @param storage
* storage back-end that should be reference counted.
* @throws IllegalArgumentException
* when storage is null
*/
public MultiReferenceStorage(Storage storage) {
if (storage == null)
throw new IllegalArgumentException();
this.storage = storage;
this.referenceCounter = 1; // caller holds first reference
}
/**
* Increments the reference counter.
*
* @throws IllegalStateException
* if the reference counter is zero which implies that the
* backing storage has already been deleted.
*/
public void addReference() {
incrementCounter();
}
/**
* Decrements the reference counter and deletes the inner
* Storage object if the reference counter reaches zero.
*
* A client that holds a reference to this object must make sure not to
* invoke this method a second time.
*
* @throws IllegalStateException
* if the reference counter is zero which implies that the
* backing storage has already been deleted.
*/
public void delete() {
if (decrementCounter()) {
storage.delete();
}
}
/**
* Returns the input stream of the inner Storage object.
*
* @return an input stream.
*/
public InputStream getInputStream() throws IOException {
return storage.getInputStream();
}
/**
* Synchronized increment of reference count.
*
* @throws IllegalStateException
* when counter is already zero
*/
private synchronized void incrementCounter() {
if (referenceCounter == 0)
throw new IllegalStateException("storage has been deleted");
referenceCounter++;
}
/**
* Synchronized decrement of reference count.
*
* @return true when counter has reached zero, false otherwise
* @throws IllegalStateException
* when counter is already zero
*/
private synchronized boolean decrementCounter() {
if (referenceCounter == 0)
throw new IllegalStateException("storage has been deleted");
return --referenceCounter == 0;
}
}
././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/ThresholdStorageProvider.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/ThresholdStoragePr0000644 0000000 0000000 00000012742 11702050530 032033 0 ustar root root /****************************************************************
* 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.storage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import org.apache.james.mime4j.util.ByteArrayBuffer;
/**
* A {@link StorageProvider} that keeps small amounts of data in memory and
* writes the remainder to another StorageProvider (the back-end)
* if a certain threshold size gets exceeded.
*
* Example usage: * *
* StorageProvider tempStore = new TempFileStorageProvider(); * StorageProvider provider = new ThresholdStorageProvider(tempStore, 4096); * DefaultStorageProvider.setInstance(provider); **/ public class ThresholdStorageProvider extends AbstractStorageProvider { private final StorageProvider backend; private final int thresholdSize; /** * Creates a new
ThresholdStorageProvider for the given
* back-end using a threshold size of 2048 bytes.
*/
public ThresholdStorageProvider(StorageProvider backend) {
this(backend, 2048);
}
/**
* Creates a new ThresholdStorageProvider for the given
* back-end and threshold size.
*
* @param backend
* used to store the remainder of the data if the threshold size
* gets exceeded.
* @param thresholdSize
* determines how much bytes are kept in memory before that
* back-end storage provider is used to store the remainder of
* the data.
*/
public ThresholdStorageProvider(StorageProvider backend, int thresholdSize) {
if (backend == null)
throw new IllegalArgumentException();
if (thresholdSize < 1)
throw new IllegalArgumentException();
this.backend = backend;
this.thresholdSize = thresholdSize;
}
public StorageOutputStream createStorageOutputStream() {
return new ThresholdStorageOutputStream();
}
private final class ThresholdStorageOutputStream extends
StorageOutputStream {
private final ByteArrayBuffer head;
private StorageOutputStream tail;
public ThresholdStorageOutputStream() {
final int bufferSize = Math.min(thresholdSize, 1024);
head = new ByteArrayBuffer(bufferSize);
}
@Override
public void close() throws IOException {
super.close();
if (tail != null)
tail.close();
}
@Override
protected void write0(byte[] buffer, int offset, int length)
throws IOException {
int remainingHeadSize = thresholdSize - head.length();
if (remainingHeadSize > 0) {
int n = Math.min(remainingHeadSize, length);
head.append(buffer, offset, n);
offset += n;
length -= n;
}
if (length > 0) {
if (tail == null)
tail = backend.createStorageOutputStream();
tail.write(buffer, offset, length);
}
}
@Override
protected Storage toStorage0() throws IOException {
if (tail == null)
return new MemoryStorageProvider.MemoryStorage(head.buffer(),
head.length());
return new ThresholdStorage(head.buffer(), head.length(), tail
.toStorage());
}
}
private static final class ThresholdStorage implements Storage {
private byte[] head;
private final int headLen;
private Storage tail;
public ThresholdStorage(byte[] head, int headLen, Storage tail) {
this.head = head;
this.headLen = headLen;
this.tail = tail;
}
public void delete() {
if (head != null) {
head = null;
tail.delete();
tail = null;
}
}
public InputStream getInputStream() throws IOException {
if (head == null)
throw new IllegalStateException("storage has been deleted");
InputStream headStream = new ByteArrayInputStream(head, 0, headLen);
InputStream tailStream = tail.getInputStream();
return new SequenceInputStream(headStream, tailStream);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageProvider.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageProvider.ja0000644 0000000 0000000 00000004472 11702050530 031761 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
/**
* Provides a strategy for storing the contents of an InputStream
* or retrieving the content written to an OutputStream.
*/
public interface StorageProvider {
/**
* Stores the contents of the given InputStream.
*
* @param in stream containing the data to store.
* @return a {@link Storage} instance that can be used to retrieve the
* stored content.
* @throws IOException if an I/O error occurs.
*/
Storage store(InputStream in) throws IOException;
/**
* Creates a {@link StorageOutputStream} where data to be stored can be
* written to. Subsequently the user can call
* {@link StorageOutputStream#toStorage() toStorage()} on that object to get
* a {@link Storage} instance that holds the data that has been written.
*
* @return a {@link StorageOutputStream} where data can be written to.
* @throws IOException
* if an I/O error occurs.
*/
StorageOutputStream createStorageOutputStream() throws IOException;
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/DefaultStorageProvider.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/DefaultStorageProv0000644 0000000 0000000 00000006460 11702050530 032030 0 ustar root root /****************************************************************
* 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.storage;
/**
* Allows for a default {@link StorageProvider} instance to be configured on an
* application level.
*
* The default instance can be set by either calling
* {@link #setInstance(StorageProvider)} when the application starts up or by
* setting the system property
* org.apache.james.mime4j.defaultStorageProvider to the class
* name of a StorageProvider implementation.
*
* If neither option is used or if the class instantiation fails this class
* provides a pre-configured default instance.
*/
public class DefaultStorageProvider {
/** Value is org.apache.james.mime4j.defaultStorageProvider */
public static final String DEFAULT_STORAGE_PROVIDER_PROPERTY =
"org.apache.james.mime4j.defaultStorageProvider";
private static volatile StorageProvider instance = null;
static {
initialize();
}
private DefaultStorageProvider() {
}
/**
* Returns the default {@link StorageProvider} instance.
*
* @return the default {@link StorageProvider} instance.
*/
public static StorageProvider getInstance() {
return instance;
}
/**
* Sets the default {@link StorageProvider} instance.
*
* @param instance
* the default {@link StorageProvider} instance.
*/
public static void setInstance(StorageProvider instance) {
if (instance == null) {
throw new IllegalArgumentException();
}
DefaultStorageProvider.instance = instance;
}
private static void initialize() {
String clazz = System.getProperty(DEFAULT_STORAGE_PROVIDER_PROPERTY);
try {
if (clazz != null) {
instance = (StorageProvider) Class.forName(clazz).newInstance();
}
} catch (Exception e) {
}
if (instance == null) {
StorageProvider backend = new TempFileStorageProvider();
instance = new ThresholdStorageProvider(backend, 1024);
}
}
// for unit tests only
static void reset() {
instance = null;
initialize();
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageOutputStream.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageOutputStrea0000644 0000000 0000000 00000014135 11702050530 032072 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.OutputStream;
/**
* This class implements an output stream that can be used to create a
* {@link Storage} object. An instance of this class is obtained by calling
* {@link StorageProvider#createStorageOutputStream()}. The user can then write
* data to this instance and invoke {@link #toStorage()} to retrieve a
* {@link Storage} object that contains the data that has been written.
*
* Note that the StorageOutputStream does not have to be closed
* explicitly because {@link #toStorage()} invokes {@link #close()} if
* necessary. Also note that {@link #toStorage()} may be invoked only once. One
* StorageOutputStream can create only one Storage
* instance.
*/
public abstract class StorageOutputStream extends OutputStream {
private byte[] singleByte;
private boolean closed;
private boolean usedUp;
/**
* Sole constructor.
*/
protected StorageOutputStream() {
}
/**
* Closes this output stream if it has not already been closed and returns a
* {@link Storage} object which contains the bytes that have been written to
* this output stream.
*
* Note that this method may not be invoked a second time. This is because
* for some implementations it is not possible to create another
* Storage object that can be read from and deleted
* independently (e.g. if the implementation writes to a file).
*
* @return a Storage object as described above.
* @throws IOException
* if an I/O error occurs.
* @throws IllegalStateException
* if this method has already been called.
*/
public final Storage toStorage() throws IOException {
if (usedUp)
throw new IllegalStateException(
"toStorage may be invoked only once");
if (!closed)
close();
usedUp = true;
return toStorage0();
}
@Override
public final void write(int b) throws IOException {
if (closed)
throw new IOException("StorageOutputStream has been closed");
if (singleByte == null)
singleByte = new byte[1];
singleByte[0] = (byte) b;
write0(singleByte, 0, 1);
}
@Override
public final void write(byte[] buffer) throws IOException {
if (closed)
throw new IOException("StorageOutputStream has been closed");
if (buffer == null)
throw new NullPointerException();
if (buffer.length == 0)
return;
write0(buffer, 0, buffer.length);
}
@Override
public final void write(byte[] buffer, int offset, int length)
throws IOException {
if (closed)
throw new IOException("StorageOutputStream has been closed");
if (buffer == null)
throw new NullPointerException();
if (offset < 0 || length < 0 || offset + length > buffer.length)
throw new IndexOutOfBoundsException();
if (length == 0)
return;
write0(buffer, offset, length);
}
/**
* Closes this output stream. Subclasses that override this method have to
* invoke super.close().
*
* This implementation never throws an {@link IOException} but a subclass
* might.
*
* @throws IOException
* if an I/O error occurs.
*/
@Override
public void close() throws IOException {
closed = true;
}
/**
* Has to implemented by a concrete subclass to write bytes from the given
* byte array to this StorageOutputStream. This method gets
* called by {@link #write(int)}, {@link #write(byte[])} and
* {@link #write(byte[], int, int)}. All the required preconditions have
* already been checked by these methods, including the check if the output
* stream has already been closed.
*
* @param buffer
* buffer containing bytes to write.
* @param offset
* start offset in the buffer.
* @param length
* number of bytes to write.
* @throws IOException
* if an I/O error occurs.
*/
protected abstract void write0(byte[] buffer, int offset, int length)
throws IOException;
/**
* Has to be implemented by a concrete subclass to create a {@link Storage}
* object from the bytes that have been written to this
* StorageOutputStream. This method gets called by
* {@link #toStorage()} after the preconditions have been checked. The
* implementation can also be sure that this methods gets invoked only once.
*
* @return a Storage object as described above.
* @throws IOException
* if an I/O error occurs.
*/
protected abstract Storage toStorage0() throws IOException;
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/MemoryStorageProvider.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/MemoryStorageProvi0000644 0000000 0000000 00000005652 11702050530 032067 0 ustar root root /****************************************************************
* 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.storage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.apache.james.mime4j.util.ByteArrayBuffer;
/**
* A {@link StorageProvider} that stores the data entirely in memory.
*
* Example usage: * *
* StorageProvider provider = new MemoryStorageProvider(); * DefaultStorageProvider.setInstance(provider); **/ public class MemoryStorageProvider extends AbstractStorageProvider { /** * Creates a new
MemoryStorageProvider.
*/
public MemoryStorageProvider() {
}
public StorageOutputStream createStorageOutputStream() {
return new MemoryStorageOutputStream();
}
private static final class MemoryStorageOutputStream extends
StorageOutputStream {
ByteArrayBuffer bab = new ByteArrayBuffer(1024);
@Override
protected void write0(byte[] buffer, int offset, int length)
throws IOException {
bab.append(buffer, offset, length);
}
@Override
protected Storage toStorage0() throws IOException {
return new MemoryStorage(bab.buffer(), bab.length());
}
}
static final class MemoryStorage implements Storage {
private byte[] data;
private final int count;
public MemoryStorage(byte[] data, int count) {
this.data = data;
this.count = count;
}
public InputStream getInputStream() throws IOException {
if (data == null)
throw new IllegalStateException("storage has been deleted");
return new ByteArrayInputStream(data, 0, count);
}
public void delete() {
data = null;
}
}
}
apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/Storage.java 0000644 0000000 0000000 00000004523 11702050530 030572 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
/**
* Can be used to read data that has been stored by a {@link StorageProvider}.
*/
public interface Storage {
/**
* Returns an InputStream that can be used to read the stored
* data. The input stream should be closed by the caller when it is no
* longer needed.
*
* Note: The stream should NOT be wrapped in a
* BufferedInputStream by the caller. If the implementing
* Storage creates a stream which would benefit from being
* buffered it is the Storage's responsibility to wrap it.
*
* @return an InputStream for reading the stored data.
* @throws IOException
* if an I/O error occurs.
* @throws IllegalStateException
* if this Storage instance has been deleted.
*/
InputStream getInputStream() throws IOException;
/**
* Deletes the data held by this Storage as soon as possible.
* Deleting an already deleted Storage has no effect.
*/
void delete();
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/CipherStorageProvider.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/CipherStorageProvi0000644 0000000 0000000 00000014463 11702050530 032031 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
import java.security.GeneralSecurityException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
/**
* A {@link StorageProvider} that transparently scrambles and unscrambles the
* data stored by another StorageProvider.
*
*
* Example usage: * *
* StorageProvider mistrusted = new TempFileStorageProvider(); * StorageProvider enciphered = new CipherStorageProvider(mistrusted); * StorageProvider provider = new ThresholdStorageProvider(enciphered); * DefaultStorageProvider.setInstance(provider); **/ public class CipherStorageProvider extends AbstractStorageProvider { private final StorageProvider backend; private final String algorithm; private final KeyGenerator keygen; /** * Creates a new
CipherStorageProvider for the given back-end
* using the Blowfish cipher algorithm.
*
* @param backend
* back-end storage strategy to encrypt.
*/
public CipherStorageProvider(StorageProvider backend) {
this(backend, "Blowfish");
}
/**
* Creates a new CipherStorageProvider for the given back-end
* and cipher algorithm.
*
* @param backend
* back-end storage strategy to encrypt.
* @param algorithm
* the name of the symmetric block cipher algorithm such as
* "Blowfish", "AES" or "RC2".
*/
public CipherStorageProvider(StorageProvider backend, String algorithm) {
if (backend == null)
throw new IllegalArgumentException();
try {
this.backend = backend;
this.algorithm = algorithm;
this.keygen = KeyGenerator.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
throw new IllegalArgumentException(e);
}
}
public StorageOutputStream createStorageOutputStream() throws IOException {
SecretKeySpec skeySpec = getSecretKeySpec();
return new CipherStorageOutputStream(backend
.createStorageOutputStream(), algorithm, skeySpec);
}
private SecretKeySpec getSecretKeySpec() {
byte[] raw = keygen.generateKey().getEncoded();
return new SecretKeySpec(raw, algorithm);
}
private static final class CipherStorageOutputStream extends
StorageOutputStream {
private final StorageOutputStream storageOut;
private final String algorithm;
private final SecretKeySpec skeySpec;
private final CipherOutputStream cipherOut;
public CipherStorageOutputStream(StorageOutputStream out,
String algorithm, SecretKeySpec skeySpec) throws IOException {
try {
this.storageOut = out;
this.algorithm = algorithm;
this.skeySpec = skeySpec;
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
this.cipherOut = new CipherOutputStream(out, cipher);
} catch (GeneralSecurityException e) {
throw (IOException) new IOException().initCause(e);
}
}
@Override
public void close() throws IOException {
super.close();
cipherOut.close();
}
@Override
protected void write0(byte[] buffer, int offset, int length)
throws IOException {
cipherOut.write(buffer, offset, length);
}
@Override
protected Storage toStorage0() throws IOException {
// cipherOut has already been closed because toStorage calls close
Storage encrypted = storageOut.toStorage();
return new CipherStorage(encrypted, algorithm, skeySpec);
}
}
private static final class CipherStorage implements Storage {
private Storage encrypted;
private final String algorithm;
private final SecretKeySpec skeySpec;
public CipherStorage(Storage encrypted, String algorithm,
SecretKeySpec skeySpec) {
this.encrypted = encrypted;
this.algorithm = algorithm;
this.skeySpec = skeySpec;
}
public void delete() {
if (encrypted != null) {
encrypted.delete();
encrypted = null;
}
}
public InputStream getInputStream() throws IOException {
if (encrypted == null)
throw new IllegalStateException("storage has been deleted");
try {
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
InputStream in = encrypted.getInputStream();
return new CipherInputStream(in, cipher);
} catch (GeneralSecurityException e) {
throw (IOException) new IOException().initCause(e);
}
}
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageBinaryBody.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageBinaryBody.0000644 0000000 0000000 00000004737 11702050530 031722 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.james.mime4j.codec.CodecUtil;
import org.apache.james.mime4j.dom.BinaryBody;
/**
* Binary body backed by a
* {@link org.apache.james.mime4j.storage.Storage}
*/
class StorageBinaryBody extends BinaryBody {
private MultiReferenceStorage storage;
public StorageBinaryBody(final MultiReferenceStorage storage) {
this.storage = storage;
}
@Override
public InputStream getInputStream() throws IOException {
return storage.getInputStream();
}
@Override
public void writeTo(OutputStream out) throws IOException {
if (out == null)
throw new IllegalArgumentException();
InputStream in = storage.getInputStream();
CodecUtil.copy(in, out);
in.close();
}
@Override
public StorageBinaryBody copy() {
storage.addReference();
return new StorageBinaryBody(storage);
}
/**
* Deletes the Storage that holds the content of this binary body.
*
* @see org.apache.james.mime4j.dom.Disposable#dispose()
*/
@Override
public void dispose() {
if (storage != null) {
storage.delete();
storage = null;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageBodyFactory.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageBodyFactory0000644 0000000 0000000 00000026466 11702050530 032032 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import org.apache.james.mime4j.codec.DecodeMonitor;
import org.apache.james.mime4j.dom.BinaryBody;
import org.apache.james.mime4j.dom.Disposable;
import org.apache.james.mime4j.dom.SingleBody;
import org.apache.james.mime4j.dom.TextBody;
import org.apache.james.mime4j.message.BodyFactory;
import org.apache.james.mime4j.util.CharsetUtil;
/**
* Factory for creating message bodies.
*/
public class StorageBodyFactory implements BodyFactory {
private static final Charset FALLBACK_CHARSET = CharsetUtil.DEFAULT_CHARSET;
private final StorageProvider storageProvider;
private final DecodeMonitor monitor;
/**
* Creates a new BodyFactory instance that uses the default
* storage provider for creating message bodies from input streams.
*/
public StorageBodyFactory() {
this(null, null);
}
/**
* Creates a new BodyFactory instance that uses the given
* storage provider for creating message bodies from input streams.
*
* @param storageProvider
* a storage provider or null to use the default
* one.
*/
public StorageBodyFactory(
final StorageProvider storageProvider,
final DecodeMonitor monitor) {
this.storageProvider =
storageProvider != null ? storageProvider : DefaultStorageProvider.getInstance();
this.monitor =
monitor != null ? monitor : DecodeMonitor.SILENT;
}
/**
* Returns the StorageProvider this BodyFactory
* uses to create message bodies from input streams.
*
* @return a StorageProvider.
*/
public StorageProvider getStorageProvider() {
return storageProvider;
}
/**
* Creates a {@link BinaryBody} that holds the content of the given input
* stream.
*
* @param is
* input stream to create a message body from.
* @return a binary body.
* @throws IOException
* if an I/O error occurs.
*/
public BinaryBody binaryBody(InputStream is) throws IOException {
if (is == null)
throw new IllegalArgumentException();
Storage storage = storageProvider.store(is);
return new StorageBinaryBody(new MultiReferenceStorage(storage));
}
/**
* Creates a {@link BinaryBody} that holds the content of the given
* {@link Storage}.
*
* Note that the caller must not invoke {@link Storage#delete() delete()} on
* the given Storage object after it has been passed to this
* method. Instead the message body created by this method takes care of
* deleting the storage when it gets disposed of (see
* {@link Disposable#dispose()}).
*
* @param storage
* storage to create a message body from.
* @return a binary body.
* @throws IOException
* if an I/O error occurs.
*/
public BinaryBody binaryBody(Storage storage) throws IOException {
if (storage == null)
throw new IllegalArgumentException();
return new StorageBinaryBody(new MultiReferenceStorage(storage));
}
/**
* Creates a {@link TextBody} that holds the content of the given input
* stream.
*
* "us-ascii" is used to decode the byte content of the
* Storage into a character stream when calling
* {@link TextBody#getReader() getReader()} on the returned object.
*
* @param is
* input stream to create a message body from.
* @return a text body.
* @throws IOException
* if an I/O error occurs.
*/
public TextBody textBody(InputStream is) throws IOException {
if (is == null)
throw new IllegalArgumentException();
Storage storage = storageProvider.store(is);
return new StorageTextBody(new MultiReferenceStorage(storage),
CharsetUtil.DEFAULT_CHARSET);
}
/**
* Creates a {@link TextBody} that holds the content of the given input
* stream.
*
* The charset corresponding to the given MIME charset name is used to * decode the byte content of the input stream into a character stream when * calling {@link TextBody#getReader() getReader()} on the returned object. * If the MIME charset has no corresponding Java charset or the Java charset * cannot be used for decoding then "us-ascii" is used instead. * * @param is * input stream to create a message body from. * @param mimeCharset * name of a MIME charset. * @return a text body. * @throws IOException * if an I/O error occurs. */ public TextBody textBody(InputStream is, String mimeCharset) throws IOException { if (is == null) throw new IllegalArgumentException(); if (mimeCharset == null) throw new IllegalArgumentException(); Storage storage = storageProvider.store(is); Charset charset = toJavaCharset(mimeCharset, false, monitor); return new StorageTextBody(new MultiReferenceStorage(storage), charset); } /** * Creates a {@link TextBody} that holds the content of the given * {@link Storage}. *
* "us-ascii" is used to decode the byte content of the
* Storage into a character stream when calling
* {@link TextBody#getReader() getReader()} on the returned object.
*
* Note that the caller must not invoke {@link Storage#delete() delete()} on
* the given Storage object after it has been passed to this
* method. Instead the message body created by this method takes care of
* deleting the storage when it gets disposed of (see
* {@link Disposable#dispose()}).
*
* @param storage
* storage to create a message body from.
* @return a text body.
* @throws IOException
* if an I/O error occurs.
*/
public TextBody textBody(Storage storage) throws IOException {
if (storage == null)
throw new IllegalArgumentException();
return new StorageTextBody(new MultiReferenceStorage(storage),
CharsetUtil.DEFAULT_CHARSET);
}
/**
* Creates a {@link TextBody} that holds the content of the given
* {@link Storage}.
*
* The charset corresponding to the given MIME charset name is used to
* decode the byte content of the Storage into a character
* stream when calling {@link TextBody#getReader() getReader()} on the
* returned object. If the MIME charset has no corresponding Java charset or
* the Java charset cannot be used for decoding then "us-ascii" is
* used instead.
*
* Note that the caller must not invoke {@link Storage#delete() delete()} on
* the given Storage object after it has been passed to this
* method. Instead the message body created by this method takes care of
* deleting the storage when it gets disposed of (see
* {@link Disposable#dispose()}).
*
* @param storage
* storage to create a message body from.
* @param mimeCharset
* name of a MIME charset.
* @return a text body.
* @throws IOException
* if an I/O error occurs.
*/
public TextBody textBody(Storage storage, String mimeCharset)
throws IOException {
if (storage == null)
throw new IllegalArgumentException();
if (mimeCharset == null)
throw new IllegalArgumentException();
Charset charset = toJavaCharset(mimeCharset, false, monitor);
return new StorageTextBody(new MultiReferenceStorage(storage), charset);
}
/**
* Creates a {@link TextBody} that holds the content of the given string.
*
* "us-ascii" is used to encode the characters of the string into * a byte stream when calling * {@link SingleBody#writeTo(java.io.OutputStream) writeTo(OutputStream)} on * the returned object. * * @param text * text to create a message body from. * @return a text body. */ public TextBody textBody(String text) { if (text == null) throw new IllegalArgumentException(); return new StringTextBody(text, CharsetUtil.DEFAULT_CHARSET); } /** * Creates a {@link TextBody} that holds the content of the given string. *
* The charset corresponding to the given MIME charset name is used to
* encode the characters of the string into a byte stream when calling
* {@link SingleBody#writeTo(java.io.OutputStream) writeTo(OutputStream)} on
* the returned object. If the MIME charset has no corresponding Java
* charset or the Java charset cannot be used for encoding then
* "us-ascii" is used instead.
*
* @param text
* text to create a message body from.
* @param mimeCharset
* name of a MIME charset.
* @return a text body.
*/
public TextBody textBody(String text, String mimeCharset) {
if (text == null)
throw new IllegalArgumentException();
if (mimeCharset == null)
throw new IllegalArgumentException();
Charset charset = toJavaCharset(mimeCharset, true, monitor);
return new StringTextBody(text, charset);
}
private static Charset toJavaCharset(
final String mimeCharset,
boolean forEncoding,
final DecodeMonitor monitor) {
Charset charset = CharsetUtil.lookup(mimeCharset);
if (charset == null) {
if (monitor.isListening()) {
monitor.warn(
"MIME charset '" + mimeCharset + "' has no "
+ "corresponding Java charset", "Using "
+ FALLBACK_CHARSET + " instead.");
}
return FALLBACK_CHARSET;
}
return charset;
}
}
././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/AbstractStorageProvider.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/AbstractStoragePro0000644 0000000 0000000 00000005121 11702050530 032012 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
import org.apache.james.mime4j.codec.CodecUtil;
/**
* Abstract implementation of {@link StorageProvider} that implements
* {@link StorageProvider#store(InputStream) store(InputStream)} by copying the
* input stream to a {@link StorageOutputStream} obtained from
* {@link StorageProvider#createStorageOutputStream() createStorageOutputStream()}.
*/
public abstract class AbstractStorageProvider implements StorageProvider {
/**
* Sole constructor.
*/
protected AbstractStorageProvider() {
}
/**
* This implementation creates a {@link StorageOutputStream} by calling
* {@link StorageProvider#createStorageOutputStream() createStorageOutputStream()}
* and copies the content of the given input stream to that output stream.
* It then calls {@link StorageOutputStream#toStorage()} on the output
* stream and returns this object.
*
* @param in
* stream containing the data to store.
* @return a {@link Storage} instance that can be used to retrieve the
* stored content.
* @throws IOException
* if an I/O error occurs.
*/
public final Storage store(InputStream in) throws IOException {
StorageOutputStream out = createStorageOutputStream();
CodecUtil.copy(in, out);
return out.toStorage();
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageTextBody.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StorageTextBody.ja0000644 0000000 0000000 00000005015 11702050530 031723 0 ustar root root /****************************************************************
* 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.storage;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import org.apache.james.mime4j.dom.TextBody;
/**
* Text body backed by a {@link org.apache.james.mime4j.storage.Storage}.
*/
class StorageTextBody extends TextBody {
private MultiReferenceStorage storage;
private Charset charset;
public StorageTextBody(MultiReferenceStorage storage, Charset charset) {
this.storage = storage;
this.charset = charset;
}
@Override
public String getMimeCharset() {
return charset.name();
}
@Override
public Reader getReader() throws IOException {
return new InputStreamReader(storage.getInputStream(), charset);
}
@Override
public InputStream getInputStream() throws IOException {
return storage.getInputStream();
}
@Override
public StorageTextBody copy() {
storage.addReference();
return new StorageTextBody(storage, charset);
}
/**
* Deletes the Storage that holds the content of this text body.
*
* @see org.apache.james.mime4j.dom.Disposable#dispose()
*/
@Override
public void dispose() {
if (storage != null) {
storage.delete();
storage = null;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StringTextBody.java apache-mime4j-project-0.7.2/storage/src/main/java/org/apache/james/mime4j/storage/StringTextBody.jav0000644 0000000 0000000 00000005423 11702050530 031756 0 ustar root root /****************************************************************
* 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.storage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.Writer;
import java.nio.charset.Charset;
import org.apache.james.mime4j.dom.TextBody;
/**
* Text body backed by a
Apache James Mime4J is developed by the
Apache James team but now has a
dedicated mailing list.
Apache James Mime4J provides a parser,
The parser only deals with the structure of the message stream.
It won't do any decoding of base64 or quoted-printable encoded
header fields and bodies. This is intentional - the parser
should only provide the most basic functionality needed to build
more complex parsers. However, mime4j does include facilities to
decode bodies and fields and the The parser has been designed to be extremely tolerant against
messages violating the standards. It has been tested using a
large corpus (>5000) of e-mail messages. As a benchmark
the widely used perl mime4j can also be used to build a tree representation of an
e-mail message using the
Go to the download
pages and download the most recent
release in your preferred format, either
Go to the download
pages and download the most recent
release in your preferred format, either
Issue the following commands in a shell:
String.
*/
class StringTextBody extends TextBody {
private final String text;
private final Charset charset;
public StringTextBody(final String text, Charset charset) {
this.text = text;
this.charset = charset;
}
@Override
public String getMimeCharset() {
return charset.name();
}
@Override
public InputStream getInputStream() throws IOException {
return new ByteArrayInputStream(text.getBytes(charset.name()));
}
@Override
public Reader getReader() throws IOException {
return new StringReader(text);
}
@Override
public void writeTo(OutputStream out) throws IOException {
if (out == null)
throw new IllegalArgumentException();
Reader reader = new StringReader(text);
Writer writer = new OutputStreamWriter(out, charset);
char buffer[] = new char[1024];
while (true) {
int nChars = reader.read(buffer);
if (nChars == -1)
break;
writer.write(buffer, 0, nChars);
}
reader.close();
writer.flush();
}
@Override
public StringTextBody copy() {
return new StringTextBody(text, charset);
}
}
apache-mime4j-project-0.7.2/storage/src/test/ 0000755 0000000 0000000 00000000000 11702050530 017471 5 ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/ 0000755 0000000 0000000 00000000000 11702050530 020412 5 ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/ 0000755 0000000 0000000 00000000000 11702050530 021201 5 ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/ 0000755 0000000 0000000 00000000000 11702050530 022422 5 ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/ 0000755 0000000 0000000 00000000000 11702050530 023521 5 ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/ 0000755 0000000 0000000 00000000000 11702050530 024706 5 ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/ 0000755 0000000 0000000 00000000000 11702050530 026352 5 ustar root root ././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/SingleBodyCopyTest.java apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/SingleBodyCopyTest0000644 0000000 0000000 00000011567 11702050530 032041 0 ustar root root /****************************************************************
* 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.storage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import junit.framework.TestCase;
import org.apache.james.mime4j.dom.SingleBody;
import org.apache.james.mime4j.message.MessageImpl;
import org.apache.james.mime4j.util.CharsetUtil;
public class SingleBodyCopyTest extends TestCase {
public void testCopyStorageBinaryBody() throws Exception {
Storage storage = new MemoryStorageProvider()
.store(new ByteArrayInputStream("test".getBytes()));
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
SingleBody body = new StorageBinaryBody(multiReferenceStorage);
copyTest(body);
}
public void testCopyStorageTextBody() throws Exception {
Storage storage = new MemoryStorageProvider()
.store(new ByteArrayInputStream("test".getBytes()));
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
SingleBody body = new StorageTextBody(multiReferenceStorage,
CharsetUtil.US_ASCII);
copyTest(body);
}
public void testCopyStringTextBody() throws Exception {
SingleBody body = new StringTextBody("test", CharsetUtil.US_ASCII);
copyTest(body);
}
public void testDisposeStorageBinaryBody() throws Exception {
Storage storage = new MemoryStorageProvider()
.store(new ByteArrayInputStream("test".getBytes()));
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
SingleBody body = new StorageBinaryBody(multiReferenceStorage);
disposeTest(body, storage);
}
public void testDisposeStorageTextBody() throws Exception {
Storage storage = new MemoryStorageProvider()
.store(new ByteArrayInputStream("test".getBytes()));
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
SingleBody body = new StorageTextBody(multiReferenceStorage,
CharsetUtil.US_ASCII);
disposeTest(body, storage);
}
private void copyTest(SingleBody body) throws Exception {
MessageImpl parent = new MessageImpl();
parent.setBody(body);
SingleBody copy = body.copy();
assertNotNull(copy);
assertNotSame(body, copy);
assertSame(parent, body.getParent());
assertNull(copy.getParent());
sameContentTest(body, copy);
}
private void sameContentTest(SingleBody expectedBody, SingleBody actualBody)
throws Exception {
ByteArrayOutputStream expBaos = new ByteArrayOutputStream();
expectedBody.writeTo(expBaos);
byte[] expected = expBaos.toByteArray();
ByteArrayOutputStream actBaos = new ByteArrayOutputStream();
actualBody.writeTo(actBaos);
byte[] actual = actBaos.toByteArray();
assertEquals(expected.length, actual.length);
for (int i = 0; i < expected.length; i++) {
assertEquals(expected[i], actual[i]);
}
}
private void disposeTest(SingleBody body, Storage storage) throws Exception {
assertTrue(storageIsReadable(storage));
SingleBody copy = body.copy();
assertTrue(storageIsReadable(storage));
body.dispose();
assertTrue(storageIsReadable(storage));
copy.dispose();
assertFalse(storageIsReadable(storage));
}
private boolean storageIsReadable(Storage storage) throws Exception {
try {
storage.getInputStream().close();
return true;
} catch (IllegalStateException e) {
return false;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000162 00000000000 011564 L ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/DefaultStorageProviderTest.java apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/DefaultStorageProv0000644 0000000 0000000 00000004772 11702050530 032067 0 ustar root root /****************************************************************
* 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.storage;
import junit.framework.TestCase;
public class DefaultStorageProviderTest extends TestCase {
@Override
protected void tearDown() throws Exception {
System.getProperties().remove(
DefaultStorageProvider.DEFAULT_STORAGE_PROVIDER_PROPERTY);
DefaultStorageProvider.reset();
}
public void testDefaultInstance() throws Exception {
System.getProperties().remove(
DefaultStorageProvider.DEFAULT_STORAGE_PROVIDER_PROPERTY);
DefaultStorageProvider.reset();
StorageProvider instance = DefaultStorageProvider.getInstance();
assertTrue(instance instanceof ThresholdStorageProvider);
}
public void testSetDefaultProperty() throws Exception {
System.setProperty(
DefaultStorageProvider.DEFAULT_STORAGE_PROVIDER_PROPERTY,
MemoryStorageProvider.class.getName());
DefaultStorageProvider.reset();
StorageProvider instance = DefaultStorageProvider.getInstance();
assertTrue(instance instanceof MemoryStorageProvider);
}
public void testSetter() throws Exception {
StorageProvider instance = new MemoryStorageProvider();
DefaultStorageProvider.setInstance(instance);
assertSame(instance, DefaultStorageProvider.getInstance());
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/MultiReferenceStorageTest.java apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/MultiReferenceStor0000644 0000000 0000000 00000007300 11702050530 032056 0 ustar root root /****************************************************************
* 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.storage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import junit.framework.TestCase;
public class MultiReferenceStorageTest extends TestCase {
public void testForwardsGetInputStream() throws Exception {
DummyStorage storage = new DummyStorage();
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
assertEquals(ByteArrayInputStream.class, multiReferenceStorage
.getInputStream().getClass());
}
public void testSingleReference() throws Exception {
DummyStorage storage = new DummyStorage();
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
assertFalse(storage.deleted);
multiReferenceStorage.delete();
assertTrue(storage.deleted);
}
public void testMultiReference() throws Exception {
DummyStorage storage = new DummyStorage();
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
multiReferenceStorage.addReference();
multiReferenceStorage.delete();
assertFalse(storage.deleted);
multiReferenceStorage.delete();
assertTrue(storage.deleted);
}
public void testGetInputStreamOnDeleted() throws Exception {
DummyStorage storage = new DummyStorage();
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
multiReferenceStorage.delete();
try {
multiReferenceStorage.getInputStream();
fail();
} catch (IllegalStateException expected) {
}
}
public void testAddReferenceOnDeleted() throws Exception {
DummyStorage storage = new DummyStorage();
MultiReferenceStorage multiReferenceStorage = new MultiReferenceStorage(
storage);
multiReferenceStorage.delete();
try {
multiReferenceStorage.addReference();
fail();
} catch (IllegalStateException expected) {
}
}
private static final class DummyStorage implements Storage {
public boolean deleted = false;
public InputStream getInputStream() throws IOException {
if (deleted)
throw new IllegalStateException("deleted");
return new ByteArrayInputStream("dummy".getBytes());
}
public void delete() {
deleted = true;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/StorageProviderTest.java apache-mime4j-project-0.7.2/storage/src/test/java/org/apache/james/mime4j/storage/StorageProviderTes0000644 0000000 0000000 00000012146 11702050530 032074 0 ustar root root /****************************************************************
* 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.storage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.apache.james.mime4j.codec.CodecUtil;
import junit.framework.TestCase;
public class StorageProviderTest extends TestCase {
public void testMemoryStorageProvider() throws Exception {
StorageProvider provider = new MemoryStorageProvider();
testReadWrite(provider, 0);
testReadWrite(provider, 1);
testReadWrite(provider, 1024);
testReadWrite(provider, 20000);
testDelete(provider);
}
public void testTempFileStorageProvider() throws Exception {
StorageProvider provider = new TempFileStorageProvider();
testReadWrite(provider, 0);
testReadWrite(provider, 1);
testReadWrite(provider, 1024);
testReadWrite(provider, 20000);
testDelete(provider);
}
public void testThresholdStorageProvider() throws Exception {
final int threshold = 5000;
StorageProvider backend = new TempFileStorageProvider();
StorageProvider provider = new ThresholdStorageProvider(backend,
threshold);
testReadWrite(provider, 0);
testReadWrite(provider, 1);
testReadWrite(provider, threshold - 1);
testReadWrite(provider, threshold);
testReadWrite(provider, threshold + 1);
testReadWrite(provider, 2 * threshold);
testReadWrite(provider, 10 * threshold);
testDelete(provider);
}
public void testCipherStorageProvider() throws Exception {
StorageProvider backend = new TempFileStorageProvider();
StorageProvider provider = new CipherStorageProvider(backend);
testReadWrite(provider, 0);
testReadWrite(provider, 1);
testReadWrite(provider, 1024);
testReadWrite(provider, 20000);
testDelete(provider);
}
private void testReadWrite(StorageProvider provider, int size)
throws IOException {
testStore(provider, size);
testCreateStorageOutputStream(provider, size);
}
private void testStore(StorageProvider provider, int size)
throws IOException {
byte[] data = createData(size);
assertEquals(size, data.length);
Storage storage = provider.store(new ByteArrayInputStream(data));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
CodecUtil.copy(storage.getInputStream(), baos);
verifyData(data, baos.toByteArray());
}
private void testCreateStorageOutputStream(StorageProvider provider,
int size) throws IOException {
byte[] data = createData(size);
assertEquals(size, data.length);
StorageOutputStream out = provider.createStorageOutputStream();
CodecUtil.copy(new ByteArrayInputStream(data), out);
Storage storage = out.toStorage();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
CodecUtil.copy(storage.getInputStream(), baos);
verifyData(data, baos.toByteArray());
}
private void verifyData(byte[] expected, byte[] actual) {
assertEquals(expected.length, actual.length);
for (int i = 0; i < expected.length; i++) {
assertEquals(expected[i], actual[i]);
}
}
private byte[] createData(int size) {
byte[] data = new byte[size];
for (int i = 0; i < size; i++) {
data[i] = (byte) i;
}
return data;
}
private void testDelete(StorageProvider provider) throws IOException {
Storage storage = provider.store(new ByteArrayInputStream(
createData(512)));
storage.delete();
// getInputStream has to throw an IllegalStateException
try {
storage.getInputStream();
fail();
} catch (IllegalStateException expected) {
}
// invoking delete a second time should not have any effect
storage.delete();
}
}
apache-mime4j-project-0.7.2/storage/src/reporting-site/ 0000755 0000000 0000000 00000000000 11702050530 021465 5 ustar root root apache-mime4j-project-0.7.2/storage/src/reporting-site/site.xml 0000644 0000000 0000000 00000001756 11702050530 023164 0 ustar root root
MimeStreamParser
, for e-mail message streams in plain rfc822 and MIME
format. The parser uses a callback mechanism to report parsing
events such as the start of an entity header, the start of a
body, etc. If you are familiar with the SAX XML parser interface
you should have no problem getting started with mime4j. Message class
described below handles decoding of fields and bodies
transparently. MIME::Tools
parser has been used. mime4j and MIME:Tools rarely differ
(<25 in those 5000). When they do (which only occurs
for illegally formatted spam messages) we think mime4j does a
better job. Message
class. Using this facility mime4j automatically handles the
decoding of fields and bodies and uses temporary files for large
attachments. This representation is similar to the
representation constructed by the JavaMail API:s but is more
tolerant to messages violating the standards.
Document
Description
Download
Before you can start using mime4j, you'll have to
download the distribution to your system (unless you
plan on building the project from source). This
document provides links to the various distributions
available.
Building mime4j
Describes how to build mime4j from the sources.
james-mime4j-x.y.tar.gz or james-mime4j-x.y.zip.
Extracting the archive will create the directory
james-mime4j-x.y/ which contains the mime4j jar file and
the API docs.james-mime4j-x.y-src.tar.gz or james-mime4j-x.y-src.zip.
Extracting the archived sources will create the directory
james-mime4j-x.y/.
svn checkout http://svn.apache.org/repos/asf/james/mime4j/trunk james-mime4j
You will need to download and install Maven before building the sources. The build has been tested with version 2.0 of Maven so use this or a later version if possible.
One of the main differences between Maven and plain ant is that Maven manages external dependencies for your projects and (at least in theory) you should no longer have to store third-party jar files in your source code tree. It maintains a local repository of versioned libraries and shares them between your Maven projects. If it can't find the necessary files there it will attempt to download them from the main Maven repository at www.ibiblio.org/maven. So to use the Maven build, you need to have a network connection available for the inital download of the project dependencies.
Once Maven has been installed, building the project should be as simple as typing
cd james-mime4j-x.y/ (cd james-mime4j/ if sources come from
Subversion)
mvn package
from the command line. Maven will
automatically run all test cases for you and create the
jar file in the target directory.
To install the jar into your local Maven repository run
mvn install
To generate an Eclipse project from the sources run
mvn eclipse:eclipse
NOTE! Mime4j uses JavaCC to generate parsers for
header fields. If you're using an old version of maven eclipse pluing
mvn eclipse:eclipse could have problems
generating proper source folders for the JavaCC generated code.
After running mvn eclipse:eclipse you must manually
add target/generated-sources/javacc and
target/generated-sources/jjtree as source folders
under Project -> Properties in Eclipse.
For more information on using Maven, have a look at the Maven web site.
The Mime4j distribution includes samples
which demonstrate how the library could be used. This section
gives you a short review of those samples. For more information
you should download the distribution and study the sample sources.
The samples are in the examples/ sub-directory.
| Sample | Description |
|---|---|
org.apache.james.mime4j.samples.tree.MessageTree
|
Displays a tree of the contents of a
Mime4j Message object in a Swing GUI.
To try it out run
The output is very useful if
you want the study the structure of MIME messages.
|
org.apache.james.mime4j.samples.transform.TransformMessage
|
Illustrate how to transform a message into another message without modifying the original. |
org.apache.james.mime4j.samples.dom.TextPlainMessage
|
Illustrate the use of Mime4j DOM API. This example generates a message very similar to the one from RFC 5322 Appendix A.1.1. |
org.apache.james.mime4j.samples.dom.MultipartMessage
|
Illustrate the use of Mime4j DOM API. This example creates a multipart/mixed message that consists of a text/plain and an image/png part. The image is created on the fly; a similar technique can be used to create PDF or XML attachments, for example. |
Ð$´+X8Ī6ÅüÕñ†Ì \CÚ $ '-Í›¼%°0ód¶#ÑZ¿, ,2ÈöÂVá<@}ÐIB«JÇwÝ m*ÿéн¢ÔñìÉE jÈ »¸RsÕ½%]-j›\:[É͹b}Ë›¦Ë™ØM §Ú58 WÕ ~püÑ2"8!U¼Û~àH–Ò½ô’¢-0¹T¶•eqÀ ° /«eªÓŽ]%ù›Tƒ ÉU;k›4Ü.€ ð½ÝÔDà _"ÚÍ›B« 4PüŒL s>F‹tz]Bœâ[Û!·ÐBPÖÿ¿2jÛ†BaƒÛwø ÊX/=0×R£ ºaHv}Å `F« }ÍÜ(Ø ¢Œƒ€mÅ„¬7¤DÍ\' ®7ЈëÛ|Q 5÷V?`ÔYõ. »Ôò\)±2£5"äwÚßH ¼ ã7 tL~6£àc=Û 22Í´RFÑ `·# .¯ÚCãÑ«¤LÄC4ú5Câ€×ÜZ`È ³8°y ÄpÛßín"Å»A4s½…4·@Mg›5 £6Ì7æö""œx˜dfOnÕJàÁc#»º¤$;E5¢ààGÖõlfþ; Ì”t7ѯ f#µ%DZP8ÿê¡x, Ë]ç|Ì.…Ãw-`Ð)¬á Ç»‹¶Õ¢qPÛ¸í9и PíŒ~0q Jí?nº”¦¬»‰ƒ€í2@.HPÃÞ«˜níÉ® #ìT Ó¸Ê3äøÞåSæ® yx Øî[¡«â1{+#Àw8p5`0†±P{&Q îÞ¾<‹t_€ »UiQi±¥w™YЃcY,¿%ßlÑGál øÐòå¹ó<ßóõ¢mPóG€ò>¿5ù¤gô‹0áŠj_yÊ#Ocr—,³E¿P ЬÀ `Úp šfÿÑm¬õ4É0• {õŒ>óÞ Ùõ|p à (` [vÁ ²yôºôF++p¸2Û _+ ¡ú=Ú lå p` ²ý\›Áêç (ñ°¦9–¦Á®5 ,qjŸ0rõ PŒ> ¦jÚªÿöJà #· P/p h<&Òž2ä uc!8`¡&¾077`7ñKê.ë«VÐF`!ÍG®ŸÍ(€°[íB ¸`Â{_ ÐW‚c0c™£ êW%ÁA7€Ù:27@t«±AxèQ…áþ½"}‰–Âø ‘I$ ×JÌ JC$¡ÿ–ÄÕ‚*š\6ŸÑióÇû/e f(¢ÊÁlp¼yÀ FÊ Ê nä’ JLpndZ¤JP" ”Pn~2^èÔ~^J~Jnd”j¾~þ”^ŒîPæŒ È4fêxpú’œŽà,ÔpLŽœ°Ž fF,Ü Nqò’PZžMÃÅïj çê”,†“pCÄGÌnÔ“ W<j”JÒàÆ (ð¸Áì‚ P ,hŠ‡ ltb¤€W PŒœ(ˆ ïÔAe+ɉ2<$ˆÀ ©~ P€ ‰MpG8 )±MI€vã&=sMN£EH&aÿÇ ¼Gþ… फ8eZxh¡A†Œ‰IVE|Ñâ Í,œZ:p#[š 8ÐÒ*É9GbîÃᡃ·¼P@uಒî~˜áï OÏÀvD'Oh8ê&yyäÑ$&è*U½šéF8‘ÜÐ(u1«‘ÌF"L@·HZð3" p$ñ Ò 0Gö`cÐJ®º QÆ, +%4”D¬ ² Æ7ûˆ*‰/f«¨n½nf·# Žþ‘+‰ÍjÝÐ Hìû!¸ÕL !#^SB á™ <’²ž‹h'0ª ÛŸ~P¨@$)DæÊ0á‹uë)‚ðÿVF¹fY…fhq…Zø䆔¸! Ll¹ÒÓ ¶Ò£‰búï „p9È~ÐLJÒªÒ´#Ä1Á1Íh€!Fˆ®¸Z‡ûà9€-9Ëî‡ ` š¸Ìxa 0á*0^!• Ïä(a:W éˆätÀ„\Á’BC¢˜jÔ±Pè´ )ô· Dy’Ë#LÖ^L ñ> QôˆO¢#SØaSœÁ×p H(Ò#ÖY3 (ïÙiW[s œA‚B;©ívµ€Ž¥hÕÈxõÖÜðÌÜuû”A<€í>:Ù×Þ{ñÍWß} ùí×ßî7 ; apache-mime4j-project-0.7.2/core/ 0000755 0000000 0000000 00000000000 11702050540 015210 5 ustar root root apache-mime4j-project-0.7.2/core/src/ 0000755 0000000 0000000 00000000000 11702050540 015777 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/ 0000755 0000000 0000000 00000000000 11702050540 016723 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/javadoc/ 0000755 0000000 0000000 00000000000 11702050540 020332 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/javadoc/overview.html 0000644 0000000 0000000 00000004213 11702050540 023066 0 ustar root root
Mime4j Core provides a parser, MimeStreamParser, for message streams in plain rfc822 and MIME format.
The parser uses a callback mechanism to report parsing events such as the start of an entity header the start of a body, etc. If you are familiar with the SAX XML parser interface you should have no problem getting started with mime4j.
The parser only deals with the structure of the message stream. It won't do any decoding of base64 or quoted-printable encoded header fields and bodies. This is intentional - the parser should only provide the most basic functionality needed to build more complex parsers. However, mime4j does include facilities to decode bodies and fields.
The parser has been designed to be tolerant against messages violating the standards. It has been tested using a large corpus (>5000) of e-mail messages. As a benchmark the widely used perl MIME::Tools parser has been used. mime4j and MIME:Tools rarely differ (<25 in those 5000). When they do (which only occurs for illegally formatted spam messages) we think mime4j does a better job.
apache-mime4j-project-0.7.2/core/src/main/java/ 0000755 0000000 0000000 00000000000 11702050536 017651 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/ 0000755 0000000 0000000 00000000000 11702050536 020440 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/ 0000755 0000000 0000000 00000000000 11702050536 021661 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/ 0000755 0000000 0000000 00000000000 11702050536 022760 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/ 0000755 0000000 0000000 00000000000 11702050540 024140 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/parser/ 0000755 0000000 0000000 00000000000 11702050540 025434 5 ustar root root ././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/parser/AbstractContentHandler.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/parser/AbstractContentHandler0000644 0000000 0000000 00000005074 11702050540 031761 0 ustar root root /**************************************************************** * 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.parser; import org.apache.james.mime4j.MimeException; import org.apache.james.mime4j.stream.BodyDescriptor; import org.apache.james.mime4j.stream.Field; import java.io.IOException; import java.io.InputStream; /** * Abstract base class for custom {@link ContentHandler} implementations. Methods of this class * take no action and are expected to be selectively overridden by super-classes. */ public abstract class AbstractContentHandler implements ContentHandler { public void endMultipart() throws MimeException { } public void startMultipart(BodyDescriptor bd) throws MimeException { } public void body(BodyDescriptor bd, InputStream is) throws MimeException, IOException { } public void endBodyPart() throws MimeException { } public void endHeader() throws MimeException { } public void endMessage() throws MimeException { } public void epilogue(InputStream is) throws MimeException, IOException { } public void field(Field field) throws MimeException { } public void preamble(InputStream is) throws MimeException, IOException { } public void startBodyPart() throws MimeException { } public void startHeader() throws MimeException { } public void startMessage() throws MimeException { } public void raw(InputStream is) throws MimeException, IOException { } } apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/parser/ContentHandler.java 0000644 0000000 0000000 00000016103 11702050540 031210 0 ustar root root /**************************************************************** * 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.parser; import org.apache.james.mime4j.MimeException; import org.apache.james.mime4j.stream.BodyDescriptor; import org.apache.james.mime4j.stream.Field; import java.io.IOException; import java.io.InputStream; /** *
* Receives notifications of the content of a plain RFC822 or MIME message.
* Implement this interface and register an instance of that implementation
* with a MimeStreamParser instance using its
* {@link org.apache.james.mime4j.parser.MimeStreamParser#setContentHandler(ContentHandler)}
* method. The parser uses the ContentHandler instance to report
* basic message-related events like the start and end of the body of a
* part in a multipart MIME entity.
*
* Throwing an exception from an event method will terminate the message * processing, i.e. no new events will be generated for that message. *
* Events will be generated in the order the corresponding elements occur in * the message stream parsed by the parser. E.g.: *
* startMessage() * startHeader() * field(...) * field(...) * ... * endHeader() * startMultipart() * preamble(...) * startBodyPart() * startHeader() * field(...) * field(...) * ... * endHeader() * body() * endBodyPart() * startBodyPart() * startHeader() * field(...) * field(...) * ... * endHeader() * body() * endBodyPart() * epilogue(...) * endMultipart() * endMessage() ** The above shows an example of a MIME message consisting of a multipart * body containing two body parts. * *
* See MIME RFCs 2045-2049 for more information on the structure of MIME * messages and RFC 822 and 2822 for the general structure of Internet mail * messages. *
*/ public interface ContentHandler { /** * Called when a new message starts (a top level message or an embedded * rfc822 message). * * @throws MimeException on processing errors */ void startMessage() throws MimeException; /** * Called when a message ends. * * @throws MimeException on processing errors */ void endMessage() throws MimeException; /** * Called when a new body part starts inside a *multipart/* entity.
*
* @throws MimeException on processing errors
*/
void startBodyPart() throws MimeException;
/**
* Called when a body part ends.
*
* @throws MimeException on processing errors
*/
void endBodyPart() throws MimeException;
/**
* Called when a header (of a message or body part) is about to be parsed.
*
* @throws MimeException on processing errors
*/
void startHeader() throws MimeException;
/**
* Called for each field of a header.
*
* @param rawField the MIME field.
* @throws MimeException on processing errors
*/
void field(Field rawField) throws MimeException;
/**
* Called when there are no more header fields in a message or body part.
*
* @throws MimeException on processing errors
*/
void endHeader() throws MimeException;
/**
* Called for the preamble (whatever comes before the first body part)
* of a multipart/* entity.
*
* @param is used to get the contents of the preamble.
* @throws MimeException on processing errors
* @throws IOException should be thrown on I/O errors.
*/
void preamble(InputStream is) throws MimeException, IOException;
/**
* Called for the epilogue (whatever comes after the final body part)
* of a multipart/* entity.
*
* @param is used to get the contents of the epilogue.
* @throws MimeException on processing errors
* @throws IOException should be thrown on I/O errors.
*/
void epilogue(InputStream is) throws MimeException, IOException;
/**
* Called when the body of a multipart entity is about to be parsed.
*
* @param bd encapsulates the values (either read from the
* message stream or, if not present, determined implictly
* as described in the
* MIME rfc:s) of the Content-Type and
* Content-Transfer-Encoding header fields.
* @throws MimeException on processing errors
*/
void startMultipart(BodyDescriptor bd) throws MimeException;
/**
* Called when the body of an entity has been parsed.
*
* @throws MimeException on processing errors
*/
void endMultipart() throws MimeException;
/**
* Called when the body of a discrete (non-multipart) entity is about to
* be parsed.
*
* @param bd see {@link #startMultipart(BodyDescriptor)}
* @param is the contents of the body. NOTE: this is the raw body contents
* - it will not be decoded if encoded. The bd
* parameter should be used to determine how the stream data
* should be decoded.
* @throws MimeException on processing errors
* @throws IOException should be thrown on I/O errors.
*/
void body(BodyDescriptor bd, InputStream is)
throws MimeException, IOException;
/**
* Called when a new entity (message or body part) starts and the
* parser is in raw mode.
*
* @param is the raw contents of the entity.
* @throws MimeException on processing errors
* @throws IOException should be thrown on I/O errors.
* @see org.apache.james.mime4j.parser.MimeStreamParser#setRaw()
*/
void raw(InputStream is) throws MimeException, IOException;
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/parser/MimeStreamParser.java 0000644 0000000 0000000 00000021336 11702050540 031524 0 ustar root root /****************************************************************
* 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.parser;
import java.io.IOException;
import java.io.InputStream;
import org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.codec.DecodeMonitor;
import org.apache.james.mime4j.stream.BodyDescriptor;
import org.apache.james.mime4j.stream.BodyDescriptorBuilder;
import org.apache.james.mime4j.stream.EntityState;
import org.apache.james.mime4j.stream.Field;
import org.apache.james.mime4j.stream.MimeConfig;
import org.apache.james.mime4j.stream.MimeTokenStream;
import org.apache.james.mime4j.stream.RecursionMode;
/**
* * Parses MIME (or RFC822) message streams of bytes or characters and reports * parsing events to a {@link ContentHandler} instance. *
*
* Typical usage:
*
* ContentHandler handler = new MyHandler();
* MimeConfig config = new MimeConfig();
* MimeStreamParser parser = new MimeStreamParser(config);
* parser.setContentHandler(handler);
* InputStream instream = new FileInputStream("mime.msg");
* try {
* parser.parse(instream);
* } finally {
* instream.close();
* }
*
*/
public class MimeStreamParser {
private ContentHandler handler = null;
private boolean contentDecoding;
private final MimeTokenStream mimeTokenStream;
public MimeStreamParser(MimeTokenStream tokenStream) {
super();
this.mimeTokenStream = tokenStream;
this.contentDecoding = false;
}
public MimeStreamParser(
final MimeConfig config,
final DecodeMonitor monitor,
final BodyDescriptorBuilder bodyDescBuilder) {
this(new MimeTokenStream(config != null ? config.clone() : new MimeConfig(),
monitor, bodyDescBuilder));
}
public MimeStreamParser(final MimeConfig config) {
this(config, null, null);
}
public MimeStreamParser() {
this(new MimeTokenStream(new MimeConfig(), null, null));
}
/**
* Determines whether this parser automatically decodes body content
* based on the on the MIME fields with the standard defaults.
*/
public boolean isContentDecoding() {
return contentDecoding;
}
/**
* Defines whether parser should automatically decode body content
* based on the on the MIME fields with the standard defaults.
*/
public void setContentDecoding(boolean b) {
this.contentDecoding = b;
}
/**
* Parses a stream of bytes containing a MIME message. Please note that if the
* {@link MimeConfig} associated with the mime stream returns a not null Content-Type
* value from its {@link MimeConfig#getHeadlessParsing()} method, the message is
* assumed to have no head section and the headless parsing mode will be used.
*
* @param instream the stream to parse.
* @throws MimeException if the message can not be processed
* @throws IOException on I/O errors.
*/
public void parse(InputStream instream) throws MimeException, IOException {
MimeConfig config = mimeTokenStream.getConfig();
if (config.getHeadlessParsing() != null) {
Field contentType = mimeTokenStream.parseHeadless(
instream, config.getHeadlessParsing());
handler.startMessage();
handler.startHeader();
handler.field(contentType);
handler.endHeader();
} else {
mimeTokenStream.parse(instream);
}
OUTER: for (;;) {
EntityState state = mimeTokenStream.getState();
switch (state) {
case T_BODY:
BodyDescriptor desc = mimeTokenStream.getBodyDescriptor();
InputStream bodyContent;
if (contentDecoding) {
bodyContent = mimeTokenStream.getDecodedInputStream();
} else {
bodyContent = mimeTokenStream.getInputStream();
}
handler.body(desc, bodyContent);
break;
case T_END_BODYPART:
handler.endBodyPart();
break;
case T_END_HEADER:
handler.endHeader();
break;
case T_END_MESSAGE:
handler.endMessage();
break;
case T_END_MULTIPART:
handler.endMultipart();
break;
case T_END_OF_STREAM:
break OUTER;
case T_EPILOGUE:
handler.epilogue(mimeTokenStream.getInputStream());
break;
case T_FIELD:
handler.field(mimeTokenStream.getField());
break;
case T_PREAMBLE:
handler.preamble(mimeTokenStream.getInputStream());
break;
case T_RAW_ENTITY:
handler.raw(mimeTokenStream.getInputStream());
break;
case T_START_BODYPART:
handler.startBodyPart();
break;
case T_START_HEADER:
handler.startHeader();
break;
case T_START_MESSAGE:
handler.startMessage();
break;
case T_START_MULTIPART:
handler.startMultipart(mimeTokenStream.getBodyDescriptor());
break;
default:
throw new IllegalStateException("Invalid state: " + state);
}
state = mimeTokenStream.next();
}
}
/**
* Determines if this parser is currently in raw mode.
*
* @return true if in raw mode, false
* otherwise.
* @see #setRaw()
*/
public boolean isRaw() {
return mimeTokenStream.isRaw();
}
/**
* Enables raw mode. In raw mode all future entities (messages
* or body parts) in the stream will be reported to the
* {@link ContentHandler#raw(InputStream)} handler method only.
* The stream will contain the entire unparsed entity contents
* including header fields and whatever is in the body.
*/
public void setRaw() {
mimeTokenStream.setRecursionMode(RecursionMode.M_RAW);
}
/**
* Enables flat mode. In flat mode rfc822 parts are not recursively
* parsed and multipart content is handled as a single "simple" stream.
*/
public void setFlat() {
mimeTokenStream.setRecursionMode(RecursionMode.M_FLAT);
}
/**
* Enables recursive mode. In this mode rfc822 parts are recursively
* parsed.
*/
public void setRecurse() {
mimeTokenStream.setRecursionMode(RecursionMode.M_RECURSE);
}
/**
* Finishes the parsing and stops reading lines.
* NOTE: No more lines will be parsed but the parser
* will still call
* {@link ContentHandler#endMultipart()},
* {@link ContentHandler#endBodyPart()},
* {@link ContentHandler#endMessage()}, etc to match previous calls
* to
* {@link ContentHandler#startMultipart(BodyDescriptor)},
* {@link ContentHandler#startBodyPart()},
* {@link ContentHandler#startMessage()}, etc.
*/
public void stop() {
mimeTokenStream.stop();
}
/**
* Sets the ContentHandler to use when reporting
* parsing events.
*
* @param h the ContentHandler.
*/
public void setContentHandler(ContentHandler h) {
this.handler = h;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/MimeIOException.java 0000644 0000000 0000000 00000004335 11702050540 030006 0 ustar root root /****************************************************************
* 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;
import java.io.IOException;
/**
* A wrapper class based on {@link IOException} for MIME protocol exceptions.
*
* This exception is used to signal a MimeException in methods
* that only permit IOException to be thrown.
*
* The cause of a MimeIOException is always a
* MimeException therefore.
*/
public class MimeIOException extends IOException {
private static final long serialVersionUID = 5393613459533735409L;
/**
* Constructs an IO exception based on {@link MimeException}.
*
* @param cause the cause.
*/
public MimeIOException(MimeException cause) {
super(cause == null ? null : cause.getMessage());
initCause(cause);
}
/**
* Returns the MimeException that caused this
* MimeIOException.
*
* @return the cause of this MimeIOException.
*/
@Override
public MimeException getCause() {
return (MimeException) super.getCause();
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/MimeException.java 0000644 0000000 0000000 00000004660 11702050540 027557 0 ustar root root /****************************************************************
* 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;
/**
* MIME processing exception.
*
* A MimeException may be thrown by a {@link org.apache.james.mime4j.parser.ContentHandler} to
* indicate that it has failed to process a message event and that no further
* events should be generated.
*
*
* Code is based on Base64 and Base64OutputStream code from Commons-Codec 1.4.
*
* @see RFC 2045
*/
public class Base64OutputStream extends FilterOutputStream {
// Default line length per RFC 2045 section 6.8.
private static final int DEFAULT_LINE_LENGTH = 76;
// CRLF line separator per RFC 2045 section 2.1.
private static final byte[] CRLF_SEPARATOR = { '\r', '\n' };
// This array is a lookup table that translates 6-bit positive integer index
// values into their "Base64 Alphabet" equivalents as specified in Table 1
// of RFC 2045.
static final byte[] BASE64_TABLE = { 'A', 'B', 'C', 'D', 'E', 'F',
'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', '+', '/' };
// Byte used to pad output.
private static final byte BASE64_PAD = '=';
// This set contains all base64 characters including the pad character. Used
// solely to check if a line separator contains any of these characters.
private static final Set
* The given line length will be rounded up to the nearest multiple of 4. If
* the line length is zero then the output will not be split into lines.
*
* @param out
* underlying output stream.
* @param lineLength
* desired line length.
*/
public Base64OutputStream(OutputStream out, int lineLength) {
this(out, lineLength, CRLF_SEPARATOR);
}
/**
* Creates a
* The given line length will be rounded up to the nearest multiple of 4. If
* the line length is zero then the output will not be split into lines and
* the line separator is ignored.
*
* The line separator must not include characters from the BASE64 alphabet
* (including the padding character
* The charset to encode the specified text into a byte array and the
* encoding to use for the encoded-word are detected automatically.
*
* This method assumes that zero characters have already been used up in the
* current line.
*
* @param text
* text to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @return the encoded word (or sequence of encoded words if the given text
* does not fit in a single encoded word).
* @see #hasToBeEncoded(String, int)
*/
public static String encodeEncodedWord(String text, Usage usage) {
return encodeEncodedWord(text, usage, 0, null, null);
}
/**
* Encodes the specified text into an encoded word or a sequence of encoded
* words separated by space. The text is separated into a sequence of
* encoded words if it does not fit in a single one.
*
* The charset to encode the specified text into a byte array and the
* encoding to use for the encoded-word are detected automatically.
*
* @param text
* text to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @param usedCharacters
* number of characters already used up (
* SUNDAY D.M., 1990,
* A very fast substring search algorithm,
* Communications of the ACM . 33(8):132-142.
*
* SUNDAY D.M., 1990,
* A very fast substring search algorithm,
* Communications of the ACM . 33(8):132-142.
*
* Default value:
* Default value:
* Default value:
* A message header may be folded across multiple lines. This configuration
* parameter is used to limit the total length of a header, i.e. the sum of
* the length of all lines the header spans across (including line
* terminators).
*
* Default value:
* Default value:
* Default value:
* Default value:
* Parses MIME (or RFC822) message streams of bytes or characters.
* The stream is converted into an event stream.
*
*
* Typical usage:
* Instances of {@link MimeTokenStream} are reusable: Invoking the
* method {@link #parse(InputStream)} resets the token streams internal
* state. However, they are definitely not thread safe. If you
* have a multi threaded application, then the suggested use is to have
* one instance per thread. 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. If the {@code MimeTokenStream} has already been in use, resets the
* streams internal state. Gets a descriptor for the current entity.
* This method is valid if {@link #getState()} returns: Gets a descriptor for the current entity.
* This method is valid if {@link #getState()} returns: The body descriptors character set, defaulted appropriately for the MIME type.
* For Hello? Am I here?
apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/2002_06_12_doublebound.xml 0000644 0000000 0000000 00000034467 11702050534 031166 0 ustar root root This message contains double boundaries all over the
place. We want to make sure that bad things don't happen.
One bad thing is that the doubled-boundary above can
be mistaken for a single boundary plus a bogus premature
end of headers.
apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/mp-msg-rfc822_decoded.xml 0000644 0000000 0000000 00000006212 11702050534 031250 0 ustar root root MimeException also gets thrown by the parser to indicate MIME
* protocol errors, e.g. if a message boundary is too long or a header field
* cannot be parsed.
*/
public class MimeException extends Exception {
private static final long serialVersionUID = 8352821278714188542L;
/**
* Constructs a new MIME exception with the specified detail message.
*
* @param message detail message
*/
public MimeException(String message) {
super(message);
}
/**
* Constructs a MIME exception with the specified cause.
*
* @param cause cause of the exception
*/
public MimeException(Throwable cause) {
super(cause);
}
/**
* Constructs a MIME exception with the specified detail message and cause.
*
* @param message detail message
* @param cause cause of the exception
*/
public MimeException(String message, Throwable cause) {
super(message, cause);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/ 0000755 0000000 0000000 00000000000 11702050540 025115 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/ByteSequence.java 0000644 0000000 0000000 00000004173 11702050540 030361 0 ustar root root /****************************************************************
* 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.util;
/**
* An immutable sequence of bytes.
*/
public interface ByteSequence {
/**
* An empty byte sequence.
*/
ByteSequence EMPTY = new EmptyByteSequence();
/**
* Returns the length of this byte sequence.
*
* @return the number of bytes in this sequence.
*/
int length();
/**
* Returns the byte value at the specified index.
*
* @param index
* the index of the byte value to be returned.
* @return the corresponding byte value
* @throws IndexOutOfBoundsException
* if index < 0 || index >= length().
*/
byte byteAt(int index);
/**
* Copies the contents of this byte sequence into a newly allocated byte
* array and returns that array.
*
* @return a byte array holding a copy of this byte sequence.
*/
byte[] toByteArray();
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/ContentUtil.java 0000644 0000000 0000000 00000013174 11702050540 030236 0 ustar root root /****************************************************************
* 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.util;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
/**
* Utility methods for converting textual content of a message.
*/
public class ContentUtil {
private ContentUtil() {
}
/**
* Encodes the specified string into an immutable sequence of bytes using
* the US-ASCII charset.
*
* @param string
* string to encode.
* @return encoded string as an immutable sequence of bytes.
*/
public static ByteSequence encode(String string) {
if (string == null) {
return null;
}
ByteArrayBuffer buf = new ByteArrayBuffer(string.length());
for (int i = 0; i < string.length(); i++) {
buf.append((byte) string.charAt(i));
}
return buf;
}
/**
* Encodes the specified string into an immutable sequence of bytes using
* the specified charset.
*
* @param charset
* Java charset to be used for the conversion.
* @param string
* string to encode.
* @return encoded string as an immutable sequence of bytes.
*/
public static ByteSequence encode(Charset charset, String string) {
if (string == null) {
return null;
}
if (charset == null) {
charset = Charset.defaultCharset();
}
ByteBuffer encoded = charset.encode(CharBuffer.wrap(string));
ByteArrayBuffer buf = new ByteArrayBuffer(encoded.remaining());
buf.append(encoded.array(), encoded.position(), encoded.remaining());
return buf;
}
/**
* Decodes the specified sequence of bytes into a string using the US-ASCII
* charset.
*
* @param byteSequence
* sequence of bytes to decode.
* @return decoded string.
*/
public static String decode(ByteSequence byteSequence) {
if (byteSequence == null) {
return null;
}
return decode(byteSequence, 0, byteSequence.length());
}
/**
* Decodes the specified sequence of bytes into a string using the specified
* charset.
*
* @param charset
* Java charset to be used for the conversion.
* @param byteSequence
* sequence of bytes to decode.
* @return decoded string.
*/
public static String decode(Charset charset, ByteSequence byteSequence) {
return decode(charset, byteSequence, 0, byteSequence.length());
}
/**
* Decodes a sub-sequence of the specified sequence of bytes into a string
* using the US-ASCII charset.
*
* @param byteSequence
* sequence of bytes to decode.
* @param offset
* offset into the byte sequence.
* @param length
* number of bytes.
* @return decoded string.
*/
public static String decode(ByteSequence byteSequence, int offset, int length) {
if (byteSequence == null) {
return null;
}
StringBuilder buf = new StringBuilder(length);
for (int i = offset; i < offset + length; i++) {
buf.append((char) (byteSequence.byteAt(i) & 0xff));
}
return buf.toString();
}
/**
* Decodes a sub-sequence of the specified sequence of bytes into a string
* using the specified charset.
*
* @param charset
* Java charset to be used for the conversion.
* @param byteSequence
* sequence of bytes to decode.
* @param offset
* offset into the byte sequence.
* @param length
* number of bytes.
* @return decoded string.
*/
public static String decode(Charset charset, ByteSequence byteSequence,
int offset, int length) {
if (byteSequence == null) {
return null;
}
if (charset == null) {
charset = Charset.defaultCharset();
}
if (byteSequence instanceof ByteArrayBuffer) {
ByteArrayBuffer bab = (ByteArrayBuffer) byteSequence;
return decode(charset, bab.buffer(), offset, length);
} else {
byte[] bytes = byteSequence.toByteArray();
return decode(charset, bytes, offset, length);
}
}
private static String decode(Charset charset, byte[] buffer, int offset,
int length) {
return charset.decode(ByteBuffer.wrap(buffer, offset, length))
.toString();
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/EmptyByteSequence.java 0000644 0000000 0000000 00000003013 11702050540 031370 0 ustar root root /****************************************************************
* 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.util;
final class EmptyByteSequence implements ByteSequence {
private static final byte[] EMPTY_BYTES = {};
public int length() {
return 0;
}
public byte byteAt(int index) {
throw new IndexOutOfBoundsException();
}
public byte[] toByteArray() {
return EMPTY_BYTES;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/ByteArrayBuffer.java 0000644 0000000 0000000 00000012163 11702050540 031017 0 ustar root root /****************************************************************
* 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.util;
/**
* A resizable byte array.
*/
public final class ByteArrayBuffer implements ByteSequence {
private byte[] buffer;
private int len;
public ByteArrayBuffer(int capacity) {
super();
if (capacity < 0) {
throw new IllegalArgumentException("Buffer capacity may not be negative");
}
this.buffer = new byte[capacity];
}
public ByteArrayBuffer(byte[] bytes, boolean dontCopy) {
this(bytes, bytes.length, dontCopy);
}
public ByteArrayBuffer(byte[] bytes, int len, boolean dontCopy) {
if (bytes == null)
throw new IllegalArgumentException();
if (len < 0 || len > bytes.length)
throw new IllegalArgumentException();
if (dontCopy) {
this.buffer = bytes;
} else {
this.buffer = new byte[len];
System.arraycopy(bytes, 0, this.buffer, 0, len);
}
this.len = len;
}
private void expand(int newlen) {
byte newbuffer[] = new byte[Math.max(this.buffer.length << 1, newlen)];
System.arraycopy(this.buffer, 0, newbuffer, 0, this.len);
this.buffer = newbuffer;
}
public void append(final byte[] b, int off, int len) {
if (b == null) {
return;
}
if ((off < 0) || (off > b.length) || (len < 0) ||
((off + len) < 0) || ((off + len) > b.length)) {
throw new IndexOutOfBoundsException();
}
if (len == 0) {
return;
}
int newlen = this.len + len;
if (newlen > this.buffer.length) {
expand(newlen);
}
System.arraycopy(b, off, this.buffer, this.len, len);
this.len = newlen;
}
public void append(int b) {
int newlen = this.len + 1;
if (newlen > this.buffer.length) {
expand(newlen);
}
this.buffer[this.len] = (byte)b;
this.len = newlen;
}
public void clear() {
this.len = 0;
}
public byte[] toByteArray() {
byte[] b = new byte[this.len];
if (this.len > 0) {
System.arraycopy(this.buffer, 0, b, 0, this.len);
}
return b;
}
public byte byteAt(int i) {
if (i < 0 || i >= this.len)
throw new IndexOutOfBoundsException();
return this.buffer[i];
}
public int capacity() {
return this.buffer.length;
}
public int length() {
return this.len;
}
public byte[] buffer() {
return this.buffer;
}
public int indexOf(byte b) {
return indexOf(b, 0, this.len);
}
public int indexOf(byte b, int beginIndex, int endIndex) {
if (beginIndex < 0) {
beginIndex = 0;
}
if (endIndex > this.len) {
endIndex = this.len;
}
if (beginIndex > endIndex) {
return -1;
}
for (int i = beginIndex; i < endIndex; i++) {
if (this.buffer[i] == b) {
return i;
}
}
return -1;
}
public void setLength(int len) {
if (len < 0 || len > this.buffer.length) {
throw new IndexOutOfBoundsException();
}
this.len = len;
}
public void remove(int off, int len) {
if ((off < 0) || (off > this.len) || (len < 0) ||
((off + len) < 0) || ((off + len) > this.len)) {
throw new IndexOutOfBoundsException();
}
if (len == 0) {
return;
}
int remaining = this.len - off - len;
if (remaining > 0) {
System.arraycopy(this.buffer, off + len, this.buffer, off, remaining);
}
this.len -= len;
}
public boolean isEmpty() {
return this.len == 0;
}
public boolean isFull() {
return this.len == this.buffer.length;
}
@Override
public String toString() {
return new String(toByteArray());
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/LangUtils.java 0000644 0000000 0000000 00000005335 11702050540 027670 0 ustar root root /****************************************************************
* 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.util;
/**
* A set of utility methods to help produce consistent
* {@link Object#equals equals} and {@link Object#hashCode hashCode} methods.
*/
public final class LangUtils {
public static final int HASH_SEED = 17;
public static final int HASH_OFFSET = 37;
/** Disabled default constructor. */
private LangUtils() {
}
public static int hashCode(final int seed, final int hashcode) {
return seed * HASH_OFFSET + hashcode;
}
public static int hashCode(final int seed, final boolean b) {
return hashCode(seed, b ? 1 : 0);
}
public static int hashCode(final int seed, final Object obj) {
return hashCode(seed, obj != null ? obj.hashCode() : 0);
}
/**
* Check if two objects are equal.
*
* @param obj1 first object to compare, may be {@code null}
* @param obj2 second object to compare, may be {@code null}
* @return {@code true} if the objects are equal or both null
*/
public static boolean equals(final Object obj1, final Object obj2) {
return obj1 == null ? obj2 == null : obj1.equals(obj2);
}
/**
* Check if two strings are equal, ignoring case considerations.
*
* @param s1 first string to compare, may be {@code null}
* @param s2 second string to compare, may be {@code null}
* @return {@code true} if the objects are equal or both null
*/
public static boolean equalsIgnoreCase(final String s1, final String s2) {
return s1 == null ? s2 == null : s1.equalsIgnoreCase(s2);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/util/MimeUtil.java 0000644 0000000 0000000 00000025054 11702050540 027513 0 ustar root root /****************************************************************
* 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.util;
import java.text.DateFormat;
import java.text.FieldPosition;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.Random;
import java.util.TimeZone;
/**
* A utility class, which provides some MIME related application logic.
*/
public final class MimeUtil {
/**
* The quoted-printable encoding.
*/
public static final String ENC_QUOTED_PRINTABLE = "quoted-printable";
/**
* The binary encoding.
*/
public static final String ENC_BINARY = "binary";
/**
* The base64 encoding.
*/
public static final String ENC_BASE64 = "base64";
/**
* The 8bit encoding.
*/
public static final String ENC_8BIT = "8bit";
/**
* The 7bit encoding.
*/
public static final String ENC_7BIT = "7bit";
// used to create unique ids
private static final Random random = new Random();
// used to create unique ids
private static int counter = 0;
private MimeUtil() {
// this is an utility class to be used statically.
// this constructor protect from instantiation.
}
/**
* Returns, whether the given two MIME types are identical.
*/
public static boolean isSameMimeType(String pType1, String pType2) {
return pType1 != null && pType2 != null && pType1.equalsIgnoreCase(pType2);
}
/**
* Returns true, if the given MIME type is that of a message.
*/
public static boolean isMessage(String pMimeType) {
return pMimeType != null && pMimeType.equalsIgnoreCase("message/rfc822");
}
/**
* Return true, if the given MIME type indicates a multipart entity.
*/
public static boolean isMultipart(String pMimeType) {
return pMimeType != null && pMimeType.toLowerCase().startsWith("multipart/");
}
/**
* Returns, whether the given transfer-encoding is "base64".
*/
public static boolean isBase64Encoding(String pTransferEncoding) {
return ENC_BASE64.equalsIgnoreCase(pTransferEncoding);
}
/**
* Returns, whether the given transfer-encoding is "quoted-printable".
*/
public static boolean isQuotedPrintableEncoded(String pTransferEncoding) {
return ENC_QUOTED_PRINTABLE.equalsIgnoreCase(pTransferEncoding);
}
/**
* Creates a new unique message boundary string that can be used as boundary
* parameter for the Content-Type header field of a message.
*
* @return a new unique message boundary string.
*/
/* TODO - From rfc2045:
* Since the hyphen character ("-") may be represented as itself in the
* Quoted-Printable encoding, care must be taken, when encapsulating a
* quoted-printable encoded body inside one or more multipart entities,
* to ensure that the boundary delimiter does not appear anywhere in the
* encoded body. (A good strategy is to choose a boundary that includes
* a character sequence such as "=_" which can never appear in a
* quoted-printable body. See the definition of multipart messages in
* RFC 2046.)
*/
public static String createUniqueBoundary() {
StringBuilder sb = new StringBuilder();
sb.append("-=Part.");
sb.append(Integer.toHexString(nextCounterValue()));
sb.append('.');
sb.append(Long.toHexString(random.nextLong()));
sb.append('.');
sb.append(Long.toHexString(System.currentTimeMillis()));
sb.append('.');
sb.append(Long.toHexString(random.nextLong()));
sb.append("=-");
return sb.toString();
}
/**
* Creates a new unique message identifier that can be used in message
* header field such as Message-ID or In-Reply-To. If the given host name is
* not null it will be used as suffix for the message ID
* (following an at sign).
*
* The resulting string is enclosed in angle brackets (< and >);
*
* @param hostName host name to be included in the message ID or
* null if no host name should be included.
* @return a new unique message identifier.
*/
public static String createUniqueMessageId(String hostName) {
StringBuilder sb = new StringBuilder("null to use the default
* time zone.
* @return the formatted time string.
*/
public static String formatDate(Date date, TimeZone zone) {
DateFormat df = RFC822_DATE_FORMAT.get();
if (zone == null) {
df.setTimeZone(TimeZone.getDefault());
} else {
df.setTimeZone(zone);
}
return df.format(date);
}
/**
* Splits the specified string into a multiple-line representation with
* lines no longer than 76 characters (because the line might contain
* encoded words; see RFC
* 2047 section 2). If the string contains non-whitespace sequences
* longer than 76 characters a line break is inserted at the whitespace
* character following the sequence resulting in a line longer than 76
* characters.
*
* @param s
* string to split.
* @param usedCharacters
* number of characters already used up. Usually the number of
* characters for header field name plus colon and one space.
* @return a multiple-line representation of the given string.
*/
public static String fold(String s, int usedCharacters) {
final int maxCharacters = 76;
final int length = s.length();
if (usedCharacters + length <= maxCharacters)
return s;
StringBuilder sb = new StringBuilder();
int lastLineBreak = -usedCharacters;
int wspIdx = indexOfWsp(s, 0);
while (true) {
if (wspIdx == length) {
sb.append(s.substring(Math.max(0, lastLineBreak)));
return sb.toString();
}
int nextWspIdx = indexOfWsp(s, wspIdx + 1);
if (nextWspIdx - lastLineBreak > maxCharacters) {
sb.append(s.substring(Math.max(0, lastLineBreak), wspIdx));
sb.append("\r\n");
lastLineBreak = wspIdx;
}
wspIdx = nextWspIdx;
}
}
/**
* Unfold a multiple-line representation into a single line.
*
* @param s
* string to unfold.
* @return unfolded string.
*/
public static String unfold(String s) {
final int length = s.length();
for (int idx = 0; idx < length; idx++) {
char c = s.charAt(idx);
if (c == '\r' || c == '\n') {
return unfold0(s, idx);
}
}
return s;
}
private static String unfold0(String s, int crlfIdx) {
final int length = s.length();
StringBuilder sb = new StringBuilder(length);
if (crlfIdx > 0) {
sb.append(s.substring(0, crlfIdx));
}
for (int idx = crlfIdx + 1; idx < length; idx++) {
char c = s.charAt(idx);
if (c != '\r' && c != '\n') {
sb.append(c);
}
}
return sb.toString();
}
private static int indexOfWsp(String s, int fromIndex) {
final int len = s.length();
for (int index = fromIndex; index < len; index++) {
char c = s.charAt(index);
if (c == ' ' || c == '\t')
return index;
}
return len;
}
private static synchronized int nextCounterValue() {
return counter++;
}
private static final ThreadLocaltrue if the specified character falls into the US
* ASCII character set (Unicode range 0000 to 007f).
*
* @param ch
* character to test.
* @return true if the specified character falls into the US
* ASCII character set, false otherwise.
*/
public static boolean isASCII(char ch) {
return (0xFF80 & ch) == 0;
}
/**
* Returns true if the specified string consists entirely of
* US ASCII characters.
*
* @param s
* string to test.
* @return true if the specified string consists entirely of
* US ASCII characters, false otherwise.
*/
public static boolean isASCII(final String s) {
if (s == null) {
throw new IllegalArgumentException("String may not be null");
}
final int len = s.length();
for (int i = 0; i < len; i++) {
if (!isASCII(s.charAt(i))) {
return false;
}
}
return true;
}
/**
* Returns true if the specified character is a whitespace
* character (CR, LF, SP or HT).
*
* @param ch
* character to test.
* @return true if the specified character is a whitespace
* character, false otherwise.
*/
public static boolean isWhitespace(char ch) {
return ch == SP || ch == HT || ch == CR || ch == LF;
}
/**
* Returns true if the specified string consists entirely of
* whitespace characters.
*
* @param s
* string to test.
* @return true if the specified string consists entirely of
* whitespace characters, false otherwise.
*/
public static boolean isWhitespace(final String s) {
if (s == null) {
throw new IllegalArgumentException("String may not be null");
}
final int len = s.length();
for (int i = 0; i < len; i++) {
if (!isWhitespace(s.charAt(i))) {
return false;
}
}
return true;
}
/**
* Returns a {@link Charset} instance if character set with the given name
* is recognized and supported by Java runtime. Returns null
* otherwise.
*
* This method is a wrapper around {@link Charset#forName(String)} method
* that catches {@link IllegalCharsetNameException} and
* {@link UnsupportedCharsetException} and returns null.
*/
public static Charset lookup(final String name) {
if (name == null) {
return null;
}
try {
return Charset.forName(name);
} catch (IllegalCharsetNameException ex) {
return null;
} catch (UnsupportedCharsetException ex) {
return null;
}
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/ 0000755 0000000 0000000 00000000000 11702050540 025215 5 ustar root root ././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/QuotedPrintableOutputStream.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/QuotedPrintableOutputSt0000644 0000000 0000000 00000016360 11702050540 032000 0 ustar root root /****************************************************************
* 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.codec;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* Performs Quoted-Printable encoding on an underlying stream.
*
* Encodes every "required" char plus the dot ".". We encode the dot
* by default because this is a workaround for some "filter"/"antivirus"
* "old mua" having issues with dots at the beginning or the end of a
* qp encode line (maybe a bad dot-destuffing algo).
*/
public class QuotedPrintableOutputStream extends FilterOutputStream {
private static final int DEFAULT_BUFFER_SIZE = 1024 * 3;
private static final byte TB = 0x09;
private static final byte SP = 0x20;
private static final byte EQ = 0x3D;
private static final byte DOT = 0x2E;
private static final byte CR = 0x0D;
private static final byte LF = 0x0A;
private static final byte QUOTED_PRINTABLE_LAST_PLAIN = 0x7E;
private static final int QUOTED_PRINTABLE_MAX_LINE_LENGTH = 76;
private static final int QUOTED_PRINTABLE_OCTETS_PER_ESCAPE = 3;
private static final byte[] HEX_DIGITS = {
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
private final byte[] outBuffer;
private final boolean binary;
private boolean pendingSpace;
private boolean pendingTab;
private boolean pendingCR;
private int nextSoftBreak;
private int outputIndex;
private boolean closed = false;
private byte[] singleByte = new byte[1];
public QuotedPrintableOutputStream(int bufsize, OutputStream out, boolean binary) {
super(out);
this.outBuffer = new byte[bufsize];
this.binary = binary;
this.pendingSpace = false;
this.pendingTab = false;
this.pendingCR = false;
this.outputIndex = 0;
this.nextSoftBreak = QUOTED_PRINTABLE_MAX_LINE_LENGTH + 1;
}
public QuotedPrintableOutputStream(OutputStream out, boolean binary) {
this(DEFAULT_BUFFER_SIZE, out, binary);
}
private void encodeChunk(byte[] buffer, int off, int len) throws IOException {
for (int inputIndex = off; inputIndex < len + off; inputIndex++) {
encode(buffer[inputIndex]);
}
}
private void completeEncoding() throws IOException {
writePending();
flushOutput();
}
private void writePending() throws IOException {
if (pendingSpace) {
plain(SP);
} else if (pendingTab) {
plain(TB);
} else if (pendingCR) {
plain(CR);
}
clearPending();
}
private void clearPending() throws IOException {
pendingSpace = false;
pendingTab = false;
pendingCR = false;
}
private void encode(byte next) throws IOException {
if (next == LF) {
if (binary) {
writePending();
escape(next);
} else {
if (pendingCR) {
// Expect either space or tab pending
// but not both
if (pendingSpace) {
escape(SP);
} else if (pendingTab) {
escape(TB);
}
lineBreak();
clearPending();
} else {
writePending();
plain(next);
}
}
} else if (next == CR) {
if (binary) {
escape(next);
} else {
pendingCR = true;
}
} else {
writePending();
if (next == SP) {
if (binary) {
escape(next);
} else {
pendingSpace = true;
}
} else if (next == TB) {
if (binary) {
escape(next);
} else {
pendingTab = true;
}
} else if (next < SP) {
escape(next);
} else if (next > QUOTED_PRINTABLE_LAST_PLAIN) {
escape(next);
} else if (next == EQ || next == DOT) {
escape(next);
} else {
plain(next);
}
}
}
private void plain(byte next) throws IOException {
if (--nextSoftBreak <= 1) {
softBreak();
}
write(next);
}
private void escape(byte next) throws IOException {
if (--nextSoftBreak <= QUOTED_PRINTABLE_OCTETS_PER_ESCAPE) {
softBreak();
}
int nextUnsigned = next & 0xff;
write(EQ);
--nextSoftBreak;
write(HEX_DIGITS[nextUnsigned >> 4]);
--nextSoftBreak;
write(HEX_DIGITS[nextUnsigned % 0x10]);
}
private void write(byte next) throws IOException {
outBuffer[outputIndex++] = next;
if (outputIndex >= outBuffer.length) {
flushOutput();
}
}
private void softBreak() throws IOException {
write(EQ);
lineBreak();
}
private void lineBreak() throws IOException {
write(CR);
write(LF);
nextSoftBreak = QUOTED_PRINTABLE_MAX_LINE_LENGTH;
}
void flushOutput() throws IOException {
if (outputIndex < outBuffer.length) {
out.write(outBuffer, 0, outputIndex);
} else {
out.write(outBuffer);
}
outputIndex = 0;
}
@Override
public void close() throws IOException {
if (closed)
return;
try {
completeEncoding();
// do not close the wrapped stream
} finally {
closed = true;
}
}
@Override
public void flush() throws IOException {
flushOutput();
}
@Override
public void write(int b) throws IOException {
singleByte[0] = (byte) b;
this.write(singleByte, 0, 1);
}
@Override
public void write(byte[] b, int off, int len) throws IOException {
if (closed) {
throw new IOException("Stream has been closed");
}
encodeChunk(b, off, len);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/CodecUtil.java 0000644 0000000 0000000 00000007564 11702050540 027747 0 ustar root root /****************************************************************
* 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.codec;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Utility methods related to codecs.
*/
public class CodecUtil {
static final int DEFAULT_ENCODING_BUFFER_SIZE = 1024;
/**
* Copies the contents of one stream to the other.
* @param in not null
* @param out not null
* @throws IOException
*/
public static void copy(final InputStream in, final OutputStream out) throws IOException {
final byte[] buffer = new byte[DEFAULT_ENCODING_BUFFER_SIZE];
int inputLength;
while (-1 != (inputLength = in.read(buffer))) {
out.write(buffer, 0, inputLength);
}
}
/**
* Encodes the given stream using Quoted-Printable.
* This assumes that stream is binary and therefore escapes
* all line endings.
* @param in not null
* @param out not null
* @throws IOException
*/
public static void encodeQuotedPrintableBinary(final InputStream in, final OutputStream out) throws IOException {
QuotedPrintableOutputStream qpOut = new QuotedPrintableOutputStream(out, true);
copy(in, qpOut);
qpOut.close();
}
/**
* Encodes the given stream using Quoted-Printable.
* This assumes that stream is text and therefore does not escape
* all line endings.
* @param in not null
* @param out not null
* @throws IOException
*/
public static void encodeQuotedPrintable(final InputStream in, final OutputStream out) throws IOException {
QuotedPrintableOutputStream qpOut = new QuotedPrintableOutputStream(out, false);
copy(in, qpOut);
qpOut.close();
}
/**
* Encodes the given stream using base64.
*
* @param in not null
* @param out not null
* @throws IOException if an I/O error occurs
*/
public static void encodeBase64(final InputStream in, final OutputStream out) throws IOException {
Base64OutputStream b64Out = new Base64OutputStream(out);
copy(in, b64Out);
b64Out.close();
}
/**
* Wraps the given stream in a Quoted-Printable encoder.
* @param out not null
* @return encoding outputstream
* @throws IOException
*/
public static OutputStream wrapQuotedPrintable(final OutputStream out, boolean binary) throws IOException {
return new QuotedPrintableOutputStream(out, binary);
}
/**
* Wraps the given stream in a Base64 encoder.
* @param out not null
* @return encoding outputstream
* @throws IOException
*/
public static OutputStream wrapBase64(final OutputStream out) throws IOException {
return new Base64OutputStream(out);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/Base64OutputStream.java0000644 0000000 0000000 00000025021 11702050540 031501 0 ustar root root /****************************************************************
* 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.codec;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.HashSet;
import java.util.Set;
/**
* This class implements section 6.8. Base64 Content-Transfer-Encoding
* from RFC 2045 Multipurpose Internet Mail Extensions (MIME) Part One:
* Format of Internet Message Bodies by Freed and Borenstein.
* Base64OutputStream that writes the encoded data
* to the given output stream using the default line length (76) and line
* separator (CRLF).
*
* @param out
* underlying output stream.
*/
public Base64OutputStream(OutputStream out) {
this(out, DEFAULT_LINE_LENGTH, CRLF_SEPARATOR);
}
/**
* Creates a Base64OutputStream that writes the encoded data
* to the given output stream using the given line length and the default
* line separator (CRLF).
* Base64OutputStream that writes the encoded data
* to the given output stream using the given line length and line
* separator.
* =).
*
* @param out
* underlying output stream.
* @param lineLength
* desired line length.
* @param lineSeparator
* line separator to use.
*/
public Base64OutputStream(OutputStream out, int lineLength,
byte[] lineSeparator) {
super(out);
if (out == null)
throw new IllegalArgumentException();
if (lineLength < 0)
throw new IllegalArgumentException();
checkLineSeparator(lineSeparator);
this.lineLength = lineLength;
this.lineSeparator = new byte[lineSeparator.length];
System.arraycopy(lineSeparator, 0, this.lineSeparator, 0,
lineSeparator.length);
this.encoded = new byte[ENCODED_BUFFER_SIZE];
}
@Override
public final void write(final int b) throws IOException {
if (closed)
throw new IOException("Base64OutputStream has been closed");
singleByte[0] = (byte) b;
write0(singleByte, 0, 1);
}
@Override
public final void write(final byte[] buffer) throws IOException {
if (closed)
throw new IOException("Base64OutputStream has been closed");
if (buffer == null)
throw new NullPointerException();
if (buffer.length == 0)
return;
write0(buffer, 0, buffer.length);
}
@Override
public final void write(final byte[] buffer, final int offset,
final int length) throws IOException {
if (closed)
throw new IOException("Base64OutputStream has been closed");
if (buffer == null)
throw new NullPointerException();
if (offset < 0 || length < 0 || offset + length > buffer.length)
throw new IndexOutOfBoundsException();
if (length == 0)
return;
write0(buffer, offset, offset + length);
}
@Override
public void flush() throws IOException {
if (closed)
throw new IOException("Base64OutputStream has been closed");
flush0();
}
@Override
public void close() throws IOException {
if (closed)
return;
closed = true;
close0();
}
private void write0(final byte[] buffer, final int from, final int to)
throws IOException {
for (int i = from; i < to; i++) {
data = (data << 8) | (buffer[i] & 0xff);
if (++modulus == 3) {
modulus = 0;
// write line separator if necessary
if (lineLength > 0 && linePosition >= lineLength) {
// writeLineSeparator() inlined for performance reasons
linePosition = 0;
if (encoded.length - position < lineSeparator.length)
flush0();
for (byte ls : lineSeparator)
encoded[position++] = ls;
}
// encode data into 4 bytes
if (encoded.length - position < 4)
flush0();
encoded[position++] = BASE64_TABLE[(data >> 18) & MASK_6BITS];
encoded[position++] = BASE64_TABLE[(data >> 12) & MASK_6BITS];
encoded[position++] = BASE64_TABLE[(data >> 6) & MASK_6BITS];
encoded[position++] = BASE64_TABLE[data & MASK_6BITS];
linePosition += 4;
}
}
}
private void flush0() throws IOException {
if (position > 0) {
out.write(encoded, 0, position);
position = 0;
}
}
private void close0() throws IOException {
if (modulus != 0)
writePad();
// write line separator at the end of the encoded data
if (lineLength > 0 && linePosition > 0) {
writeLineSeparator();
}
flush0();
}
private void writePad() throws IOException {
// write line separator if necessary
if (lineLength > 0 && linePosition >= lineLength) {
writeLineSeparator();
}
// encode data into 4 bytes
if (encoded.length - position < 4)
flush0();
if (modulus == 1) {
encoded[position++] = BASE64_TABLE[(data >> 2) & MASK_6BITS];
encoded[position++] = BASE64_TABLE[(data << 4) & MASK_6BITS];
encoded[position++] = BASE64_PAD;
encoded[position++] = BASE64_PAD;
} else {
assert modulus == 2;
encoded[position++] = BASE64_TABLE[(data >> 10) & MASK_6BITS];
encoded[position++] = BASE64_TABLE[(data >> 4) & MASK_6BITS];
encoded[position++] = BASE64_TABLE[(data << 2) & MASK_6BITS];
encoded[position++] = BASE64_PAD;
}
linePosition += 4;
}
private void writeLineSeparator() throws IOException {
linePosition = 0;
if (encoded.length - position < lineSeparator.length)
flush0();
for (byte ls : lineSeparator)
encoded[position++] = ls;
}
private void checkLineSeparator(byte[] lineSeparator) {
if (lineSeparator.length > ENCODED_BUFFER_SIZE)
throw new IllegalArgumentException("line separator length exceeds "
+ ENCODED_BUFFER_SIZE);
for (byte b : lineSeparator) {
if (BASE64_CHARS.contains(b)) {
throw new IllegalArgumentException(
"line separator must not contain base64 character '"
+ (char) (b & 0xff) + "'");
}
}
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/Base64InputStream.java 0000644 0000000 0000000 00000022234 11702050540 031303 0 ustar root root /****************************************************************
* 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.codec;
import java.io.IOException;
import java.io.InputStream;
import org.apache.james.mime4j.util.ByteArrayBuffer;
/**
* Performs Base-64 decoding on an underlying stream.
*/
public class Base64InputStream extends InputStream {
private static final int ENCODED_BUFFER_SIZE = 1536;
private static final int[] BASE64_DECODE = new int[256];
static {
for (int i = 0; i < 256; i++)
BASE64_DECODE[i] = -1;
for (int i = 0; i < Base64OutputStream.BASE64_TABLE.length; i++)
BASE64_DECODE[Base64OutputStream.BASE64_TABLE[i] & 0xff] = i;
}
private static final byte BASE64_PAD = '=';
private static final int EOF = -1;
private final byte[] singleByte = new byte[1];
private final InputStream in;
private final byte[] encoded;
private final ByteArrayBuffer decodedBuf;
private int position = 0; // current index into encoded buffer
private int size = 0; // current size of encoded buffer
private boolean closed = false;
private boolean eof; // end of file or pad character reached
private final DecodeMonitor monitor;
public Base64InputStream(InputStream in, DecodeMonitor monitor) {
this(ENCODED_BUFFER_SIZE, in, monitor);
}
protected Base64InputStream(int bufsize, InputStream in, DecodeMonitor monitor) {
if (in == null)
throw new IllegalArgumentException();
this.encoded = new byte[bufsize];
this.decodedBuf = new ByteArrayBuffer(512);
this.in = in;
this.monitor = monitor;
}
public Base64InputStream(InputStream in) {
this(in, false);
}
public Base64InputStream(InputStream in, boolean strict) {
this(ENCODED_BUFFER_SIZE, in, strict ? DecodeMonitor.STRICT : DecodeMonitor.SILENT);
}
@Override
public int read() throws IOException {
if (closed)
throw new IOException("Stream has been closed");
while (true) {
int bytes = read0(singleByte, 0, 1);
if (bytes == EOF)
return EOF;
if (bytes == 1)
return singleByte[0] & 0xff;
}
}
@Override
public int read(byte[] buffer) throws IOException {
if (closed)
throw new IOException("Stream has been closed");
if (buffer == null)
throw new NullPointerException();
if (buffer.length == 0)
return 0;
return read0(buffer, 0, buffer.length);
}
@Override
public int read(byte[] buffer, int offset, int length) throws IOException {
if (closed)
throw new IOException("Stream has been closed");
if (buffer == null)
throw new NullPointerException();
if (offset < 0 || length < 0 || offset + length > buffer.length)
throw new IndexOutOfBoundsException();
if (length == 0)
return 0;
return read0(buffer, offset, length);
}
@Override
public void close() throws IOException {
if (closed)
return;
closed = true;
}
private int read0(final byte[] buffer, final int off, final int len) throws IOException {
int from = off;
int to = off + len;
int index = off;
// check if a previous invocation left decoded content
if (decodedBuf.length() > 0) {
int chunk = Math.min(decodedBuf.length(), len);
System.arraycopy(decodedBuf.buffer(), 0, buffer, index, chunk);
decodedBuf.remove(0, chunk);
index += chunk;
}
// eof or pad reached?
if (eof)
return index == from ? EOF : index - from;
// decode into given buffer
int data = 0; // holds decoded data; up to four sextets
int sextets = 0; // number of sextets
while (index < to) {
// make sure buffer not empty
while (position == size) {
int n = in.read(encoded, 0, encoded.length);
if (n == EOF) {
eof = true;
if (sextets != 0) {
// error in encoded data
handleUnexpectedEof(sextets);
}
return index == from ? EOF : index - from;
} else if (n > 0) {
position = 0;
size = n;
} else {
assert n == 0;
}
}
// decode buffer
while (position < size && index < to) {
int value = encoded[position++] & 0xff;
if (value == BASE64_PAD) {
index = decodePad(data, sextets, buffer, index, to);
return index - from;
}
int decoded = BASE64_DECODE[value];
if (decoded < 0) { // -1: not a base64 char
if (value != 0x0D && value != 0x0A && value != 0x20) {
if (monitor.warn("Unexpected base64 byte: "+(byte) value, "ignoring."))
throw new IOException("Unexpected base64 byte");
}
continue;
}
data = (data << 6) | decoded;
sextets++;
if (sextets == 4) {
sextets = 0;
byte b1 = (byte) (data >>> 16);
byte b2 = (byte) (data >>> 8);
byte b3 = (byte) data;
if (index < to - 2) {
buffer[index++] = b1;
buffer[index++] = b2;
buffer[index++] = b3;
} else {
if (index < to - 1) {
buffer[index++] = b1;
buffer[index++] = b2;
decodedBuf.append(b3);
} else if (index < to) {
buffer[index++] = b1;
decodedBuf.append(b2);
decodedBuf.append(b3);
} else {
decodedBuf.append(b1);
decodedBuf.append(b2);
decodedBuf.append(b3);
}
assert index == to;
return to - from;
}
}
}
}
assert sextets == 0;
assert index == to;
return to - from;
}
private int decodePad(int data, int sextets, final byte[] buffer,
int index, final int end) throws IOException {
eof = true;
if (sextets == 2) {
// one byte encoded as "XY=="
byte b = (byte) (data >>> 4);
if (index < end) {
buffer[index++] = b;
} else {
decodedBuf.append(b);
}
} else if (sextets == 3) {
// two bytes encoded as "XYZ="
byte b1 = (byte) (data >>> 10);
byte b2 = (byte) ((data >>> 2) & 0xFF);
if (index < end - 1) {
buffer[index++] = b1;
buffer[index++] = b2;
} else if (index < end) {
buffer[index++] = b1;
decodedBuf.append(b2);
} else {
decodedBuf.append(b1);
decodedBuf.append(b2);
}
} else {
// error in encoded data
handleUnexpecedPad(sextets);
}
return index;
}
private void handleUnexpectedEof(int sextets) throws IOException {
if (monitor.warn("Unexpected end of BASE64 stream", "dropping " + sextets + " sextet(s)"))
throw new IOException("Unexpected end of BASE64 stream");
}
private void handleUnexpecedPad(int sextets) throws IOException {
if (monitor.warn("Unexpected padding character", "dropping " + sextets + " sextet(s)"))
throw new IOException("Unexpected padding character");
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/QuotedPrintableInputStream.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/QuotedPrintableInputStr0000644 0000000 0000000 00000025433 11702050540 031762 0 ustar root root /****************************************************************
* 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.codec;
import java.io.IOException;
import java.io.InputStream;
import org.apache.james.mime4j.util.ByteArrayBuffer;
/**
* Performs Quoted-Printable decoding on an underlying stream.
*/
public class QuotedPrintableInputStream extends InputStream {
private static final int DEFAULT_BUFFER_SIZE = 1024 * 2;
private static final byte EQ = 0x3D;
private static final byte CR = 0x0D;
private static final byte LF = 0x0A;
private final byte[] singleByte = new byte[1];
private final InputStream in;
private final ByteArrayBuffer decodedBuf;
private final ByteArrayBuffer blanks;
private final byte[] encoded;
private int pos = 0; // current index into encoded buffer
private int limit = 0; // current size of encoded buffer
private boolean closed;
private final DecodeMonitor monitor;
public QuotedPrintableInputStream(final InputStream in, DecodeMonitor monitor) {
this(DEFAULT_BUFFER_SIZE, in, monitor);
}
protected QuotedPrintableInputStream(final int bufsize, final InputStream in, DecodeMonitor monitor) {
super();
this.in = in;
this.encoded = new byte[bufsize];
this.decodedBuf = new ByteArrayBuffer(512);
this.blanks = new ByteArrayBuffer(512);
this.closed = false;
this.monitor = monitor;
}
protected QuotedPrintableInputStream(final int bufsize, final InputStream in, boolean strict) {
this(bufsize, in, strict ? DecodeMonitor.STRICT : DecodeMonitor.SILENT);
}
public QuotedPrintableInputStream(final InputStream in, boolean strict) {
this(DEFAULT_BUFFER_SIZE, in, strict);
}
public QuotedPrintableInputStream(final InputStream in) {
this(in, false);
}
/**
* Terminates Quoted-Printable coded content. This method does NOT close
* the underlying input stream.
*
* @throws IOException on I/O errors.
*/
@Override
public void close() throws IOException {
closed = true;
}
private int fillBuffer() throws IOException {
// Compact buffer if needed
if (pos < limit) {
System.arraycopy(encoded, pos, encoded, 0, limit - pos);
limit -= pos;
pos = 0;
} else {
limit = 0;
pos = 0;
}
int capacity = encoded.length - limit;
if (capacity > 0) {
int bytesRead = in.read(encoded, limit, capacity);
if (bytesRead > 0) {
limit += bytesRead;
}
return bytesRead;
} else {
return 0;
}
}
private int getnext() {
if (pos < limit) {
byte b = encoded[pos];
pos++;
return b & 0xFF;
} else {
return -1;
}
}
private int peek(int i) {
if (pos + i < limit) {
return encoded[pos + i] & 0xFF;
} else {
return -1;
}
}
private int transfer(
final int b, final byte[] buffer, final int from, final int to, boolean keepblanks) throws IOException {
int index = from;
if (keepblanks && blanks.length() > 0) {
int chunk = Math.min(blanks.length(), to - index);
System.arraycopy(blanks.buffer(), 0, buffer, index, chunk);
index += chunk;
int remaining = blanks.length() - chunk;
if (remaining > 0) {
decodedBuf.append(blanks.buffer(), chunk, remaining);
}
blanks.clear();
} else if (blanks.length() > 0 && !keepblanks) {
StringBuilder sb = new StringBuilder(blanks.length() * 3);
for (int i = 0; i < blanks.length(); i++) sb.append(" "+blanks.byteAt(i));
if (monitor.warn("ignored blanks", sb.toString()))
throw new IOException("ignored blanks");
}
if (b != -1) {
if (index < to) {
buffer[index++] = (byte) b;
} else {
decodedBuf.append(b);
}
}
return index;
}
private int read0(final byte[] buffer, final int off, final int len) throws IOException {
boolean eof = false;
int from = off;
int to = off + len;
int index = off;
// check if a previous invocation left decoded content
if (decodedBuf.length() > 0) {
int chunk = Math.min(decodedBuf.length(), to - index);
System.arraycopy(decodedBuf.buffer(), 0, buffer, index, chunk);
decodedBuf.remove(0, chunk);
index += chunk;
}
while (index < to) {
if (limit - pos < 3) {
int bytesRead = fillBuffer();
eof = bytesRead == -1;
}
// end of stream?
if (limit - pos == 0 && eof) {
return index == from ? -1 : index - from;
}
boolean lastWasCR = false;
while (pos < limit && index < to) {
int b = encoded[pos++] & 0xFF;
if (lastWasCR && b != LF) {
if (monitor.warn("Found CR without LF", "Leaving it as is"))
throw new IOException("Found CR without LF");
index = transfer(CR, buffer, index, to, false);
} else if (!lastWasCR && b == LF) {
if (monitor.warn("Found LF without CR", "Translating to CRLF"))
throw new IOException("Found LF without CR");
}
if (b == CR) {
lastWasCR = true;
continue;
} else {
lastWasCR = false;
}
if (b == LF) {
// at end of line
if (blanks.length() == 0) {
index = transfer(CR, buffer, index, to, false);
index = transfer(LF, buffer, index, to, false);
} else {
if (blanks.byteAt(0) != EQ) {
// hard line break
index = transfer(CR, buffer, index, to, false);
index = transfer(LF, buffer, index, to, false);
}
}
blanks.clear();
} else if (b == EQ) {
if (limit - pos < 2 && !eof) {
// not enough buffered data
pos--;
break;
}
// found special char '='
int b2 = getnext();
if (b2 == EQ) {
index = transfer(b2, buffer, index, to, true);
// deal with '==\r\n' brokenness
int bb1 = peek(0);
int bb2 = peek(1);
if (bb1 == LF || (bb1 == CR && bb2 == LF)) {
monitor.warn("Unexpected ==EOL encountered", "== 0x"+bb1+" 0x"+bb2);
blanks.append(b2);
} else {
monitor.warn("Unexpected == encountered", "==");
}
} else if (Character.isWhitespace((char) b2)) {
// soft line break
index = transfer(-1, buffer, index, to, true);
if (b2 != LF) {
blanks.append(b);
blanks.append(b2);
}
} else {
int b3 = getnext();
int upper = convert(b2);
int lower = convert(b3);
if (upper < 0 || lower < 0) {
monitor.warn("Malformed encoded value encountered", "leaving "+((char) EQ)+((char) b2)+((char) b3)+" as is");
// TODO see MIME4J-160
index = transfer(EQ, buffer, index, to, true);
index = transfer(b2, buffer, index, to, false);
index = transfer(b3, buffer, index, to, false);
} else {
index = transfer((upper << 4) | lower, buffer, index, to, true);
}
}
} else if (Character.isWhitespace(b)) {
blanks.append(b);
} else {
index = transfer((int) b & 0xFF, buffer, index, to, true);
}
}
}
return to - from;
}
/**
* Converts '0' => 0, 'A' => 10, etc.
* @param c ASCII character value.
* @return Numeric value of hexadecimal character.
*/
private int convert(int c) {
if (c >= '0' && c <= '9') {
return (c - '0');
} else if (c >= 'A' && c <= 'F') {
return (0xA + (c - 'A'));
} else if (c >= 'a' && c <= 'f') {
return (0xA + (c - 'a'));
} else {
return -1;
}
}
@Override
public int read() throws IOException {
if (closed) {
throw new IOException("Stream has been closed");
}
for (;;) {
int bytes = read(singleByte, 0, 1);
if (bytes == -1) {
return -1;
}
if (bytes == 1) {
return singleByte[0] & 0xff;
}
}
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
if (closed) {
throw new IOException("Stream has been closed");
}
return read0(b, off, len);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/DecodeMonitor.java 0000644 0000000 0000000 00000004205 11702050540 030614 0 ustar root root /****************************************************************
* 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.codec;
/**
* This class is used to drive how decoder/parser should deal with malformed
* and unexpected data.
*
* 2 basic implementations are provided:
*
*
*/
public class DecodeMonitor {
/**
* The STRICT monitor throws an exception on every event.
*/
public static final DecodeMonitor STRICT = new DecodeMonitor() {
@Override
public boolean warn(String error, String dropDesc) {
return true;
}
@Override
public boolean isListening() {
return true;
}
};
/**
* The SILENT monitor ignore requests.
*/
public static final DecodeMonitor SILENT = new DecodeMonitor();
public boolean warn(String error, String dropDesc) {
return false;
}
public boolean isListening() {
return false;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/codec/EncoderUtil.java 0000644 0000000 0000000 00000052550 11702050540 030304 0 ustar root root /****************************************************************
* 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.codec;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.BitSet;
import java.util.Locale;
import org.apache.james.mime4j.util.CharsetUtil;
/**
* Static methods for encoding header field values. This includes encoded-words
* as defined in RFC 2047
* or display-names of an e-mail address, for example.
*/
public class EncoderUtil {
private static final byte[] BASE64_TABLE = Base64OutputStream.BASE64_TABLE;
private static final char BASE64_PAD = '=';
private static final BitSet Q_REGULAR_CHARS = initChars("=_?");
private static final BitSet Q_RESTRICTED_CHARS = initChars("=_?\"#$%&'(),.:;<>@[\\]^`{|}~");
private static final int MAX_USED_CHARACTERS = 50;
private static final String ENC_WORD_PREFIX = "=?";
private static final String ENC_WORD_SUFFIX = "?=";
private static final int ENCODED_WORD_MAX_LENGTH = 75; // RFC 2047
private static final BitSet TOKEN_CHARS = initChars("()<>@,;:\\\"/[]?=");
private static final BitSet ATEXT_CHARS = initChars("()<>@.,;:\\\"[]");
private static BitSet initChars(String specials) {
BitSet bs = new BitSet(128);
for (char ch = 33; ch < 127; ch++) {
if (specials.indexOf(ch) == -1) {
bs.set(ch);
}
}
return bs;
}
/**
* Selects one of the two encodings specified in RFC 2047.
*/
public enum Encoding {
/** The B encoding (identical to base64 defined in RFC 2045). */
B,
/** The Q encoding (similar to quoted-printable defined in RFC 2045). */
Q
}
/**
* Indicates the intended usage of an encoded word.
*/
public enum Usage {
/**
* Encoded word is used to replace a 'text' token in any Subject or
* Comments header field.
*/
TEXT_TOKEN,
/**
* Encoded word is used to replace a 'word' entity within a 'phrase',
* for example, one that precedes an address in a From, To, or Cc
* header.
*/
WORD_ENTITY
}
private EncoderUtil() {
}
/**
* Encodes the display-name portion of an address. See RFC 5322 section 3.4
* and RFC 2047 section
* 5.3. The specified string should not be folded.
*
* @param displayName
* display-name to encode.
* @return encoded display-name.
*/
public static String encodeAddressDisplayName(String displayName) {
// display-name = phrase
// phrase = 1*( encoded-word / word )
// word = atom / quoted-string
// atom = [CFWS] 1*atext [CFWS]
// CFWS = comment or folding white space
if (isAtomPhrase(displayName)) {
return displayName;
} else if (hasToBeEncoded(displayName, 0)) {
return encodeEncodedWord(displayName, Usage.WORD_ENTITY);
} else {
return quote(displayName);
}
}
/**
* Encodes the local part of an address specification as described in RFC
* 5322 section 3.4.1. Leading and trailing CFWS should have been removed
* before calling this method. The specified string should not contain any
* illegal (control or non-ASCII) characters.
*
* @param localPart
* the local part to encode
* @return the encoded local part.
*/
public static String encodeAddressLocalPart(String localPart) {
// local-part = dot-atom / quoted-string
// dot-atom = [CFWS] dot-atom-text [CFWS]
// CFWS = comment or folding white space
if (isDotAtomText(localPart)) {
return localPart;
} else {
return quote(localPart);
}
}
/**
* Encodes the specified strings into a header parameter as described in RFC
* 2045 section 5.1 and RFC 2183 section 2. The specified strings should not
* contain any illegal (control or non-ASCII) characters.
*
* @param name
* parameter name.
* @param value
* parameter value.
* @return encoded result.
*/
public static String encodeHeaderParameter(String name, String value) {
name = name.toLowerCase(Locale.US);
// value := token / quoted-string
if (isToken(value)) {
return name + "=" + value;
} else {
return name + "=" + quote(value);
}
}
/**
* Shortcut method that encodes the specified text into an encoded-word if
* the text has to be encoded.
*
* @param text
* text to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @param usedCharacters
* number of characters already used up (0 <= usedCharacters <= 50).
* @return the specified text if encoding is not necessary or an encoded
* word or a sequence of encoded words otherwise.
*/
public static String encodeIfNecessary(String text, Usage usage,
int usedCharacters) {
if (hasToBeEncoded(text, usedCharacters))
return encodeEncodedWord(text, usage, usedCharacters);
else
return text;
}
/**
* Determines if the specified string has to encoded into an encoded-word.
* Returns true if the text contains characters that don't
* fall into the printable ASCII character set or if the text contains a
* 'word' (sequence of non-whitespace characters) longer than 77 characters
* (including characters already used up in the line).
*
* @param text
* text to analyze.
* @param usedCharacters
* number of characters already used up (0 <= usedCharacters <= 50).
* @return true if the specified text has to be encoded into
* an encoded-word, false otherwise.
*/
public static boolean hasToBeEncoded(String text, int usedCharacters) {
if (text == null)
throw new IllegalArgumentException();
if (usedCharacters < 0 || usedCharacters > MAX_USED_CHARACTERS)
throw new IllegalArgumentException();
int nonWhiteSpaceCount = usedCharacters;
for (int idx = 0; idx < text.length(); idx++) {
char ch = text.charAt(idx);
if (ch == '\t' || ch == ' ') {
nonWhiteSpaceCount = 0;
} else {
nonWhiteSpaceCount++;
if (nonWhiteSpaceCount > 77) {
// Line cannot be folded into multiple lines with no more
// than 78 characters each. Encoding as encoded-words makes
// that possible. One character has to be reserved for
// folding white space; that leaves 77 characters.
return true;
}
if (ch < 32 || ch >= 127) {
// non-printable ascii character has to be encoded
return true;
}
}
}
return false;
}
/**
* Encodes the specified text into an encoded word or a sequence of encoded
* words separated by space. The text is separated into a sequence of
* encoded words if it does not fit in a single one.
* 0 <= usedCharacters <= 50).
* @return the encoded word (or sequence of encoded words if the given text
* does not fit in a single encoded word).
* @see #hasToBeEncoded(String, int)
*/
public static String encodeEncodedWord(String text, Usage usage,
int usedCharacters) {
return encodeEncodedWord(text, usage, usedCharacters, null, null);
}
/**
* Encodes the specified text into an encoded word or a sequence of encoded
* words separated by space. The text is separated into a sequence of
* encoded words if it does not fit in a single one.
*
* @param text
* text to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @param usedCharacters
* number of characters already used up (0 <= usedCharacters <= 50).
* @param charset
* the Java charset that should be used to encode the specified
* string into a byte array. A suitable charset is detected
* automatically if this parameter is null.
* @param encoding
* the encoding to use for the encoded-word (either B or Q). A
* suitable encoding is automatically chosen if this parameter is
* null.
* @return the encoded word (or sequence of encoded words if the given text
* does not fit in a single encoded word).
* @see #hasToBeEncoded(String, int)
*/
public static String encodeEncodedWord(String text, Usage usage,
int usedCharacters, Charset charset, Encoding encoding) {
if (text == null)
throw new IllegalArgumentException();
if (usedCharacters < 0 || usedCharacters > MAX_USED_CHARACTERS)
throw new IllegalArgumentException();
if (charset == null)
charset = determineCharset(text);
byte[] bytes = encode(text, charset);
if (encoding == null)
encoding = determineEncoding(bytes, usage);
if (encoding == Encoding.B) {
String prefix = ENC_WORD_PREFIX + charset.name() + "?B?";
return encodeB(prefix, text, usedCharacters, charset, bytes);
} else {
String prefix = ENC_WORD_PREFIX + charset.name() + "?Q?";
return encodeQ(prefix, text, usage, usedCharacters, charset, bytes);
}
}
/**
* Encodes the specified byte array using the B encoding defined in RFC
* 2047.
*
* @param bytes
* byte array to encode.
* @return encoded string.
*/
public static String encodeB(byte[] bytes) {
StringBuilder sb = new StringBuilder();
int idx = 0;
final int end = bytes.length;
for (; idx < end - 2; idx += 3) {
int data = (bytes[idx] & 0xff) << 16 | (bytes[idx + 1] & 0xff) << 8
| bytes[idx + 2] & 0xff;
sb.append((char) BASE64_TABLE[data >> 18 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 12 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 6 & 0x3f]);
sb.append((char) BASE64_TABLE[data & 0x3f]);
}
if (idx == end - 2) {
int data = (bytes[idx] & 0xff) << 16 | (bytes[idx + 1] & 0xff) << 8;
sb.append((char) BASE64_TABLE[data >> 18 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 12 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 6 & 0x3f]);
sb.append(BASE64_PAD);
} else if (idx == end - 1) {
int data = (bytes[idx] & 0xff) << 16;
sb.append((char) BASE64_TABLE[data >> 18 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 12 & 0x3f]);
sb.append(BASE64_PAD);
sb.append(BASE64_PAD);
}
return sb.toString();
}
/**
* Encodes the specified byte array using the Q encoding defined in RFC
* 2047.
*
* @param bytes
* byte array to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @return encoded string.
*/
public static String encodeQ(byte[] bytes, Usage usage) {
BitSet qChars = usage == Usage.TEXT_TOKEN ? Q_REGULAR_CHARS
: Q_RESTRICTED_CHARS;
StringBuilder sb = new StringBuilder();
final int end = bytes.length;
for (int idx = 0; idx < end; idx++) {
int v = bytes[idx] & 0xff;
if (v == 32) {
sb.append('_');
} else if (!qChars.get(v)) {
sb.append('=');
sb.append(hexDigit(v >>> 4));
sb.append(hexDigit(v & 0xf));
} else {
sb.append((char) v);
}
}
return sb.toString();
}
/**
* Tests whether the specified string is a token as defined in RFC 2045
* section 5.1.
*
* @param str
* string to test.
* @return true if the specified string is a RFC 2045 token,
* false otherwise.
*/
public static boolean isToken(String str) {
// token := 1*\r
* bytes not followed by \n and \n not
* preceded by \r to \r\n.
*/
public class EOLConvertingInputStream extends InputStream {
/** Converts single '\r' to '\r\n' */
public static final int CONVERT_CR = 1;
/** Converts single '\n' to '\r\n' */
public static final int CONVERT_LF = 2;
/** Converts single '\r' and '\n' to '\r\n' */
public static final int CONVERT_BOTH = 3;
private PushbackInputStream in = null;
private int previous = 0;
private int flags = CONVERT_BOTH;
/**
* Creates a new EOLConvertingInputStream
* instance converting bytes in the given InputStream.
* The flag CONVERT_BOTH is the default.
*
* @param in the InputStream to read from.
*/
public EOLConvertingInputStream(InputStream in) {
this(in, CONVERT_BOTH);
}
/**
* Creates a new EOLConvertingInputStream
* instance converting bytes in the given InputStream.
*
* @param in the InputStream to read from.
* @param flags one of CONVERT_CR, CONVERT_LF or
* CONVERT_BOTH.
*/
public EOLConvertingInputStream(InputStream in, int flags) {
super();
this.in = new PushbackInputStream(in, 2);
this.flags = flags;
}
/**
* Closes the underlying stream.
*
* @throws IOException on I/O errors.
*/
@Override
public void close() throws IOException {
in.close();
}
/**
* @see java.io.InputStream#read()
*/
@Override
public int read() throws IOException {
int b = in.read();
if (b == -1) {
return -1;
}
if ((flags & CONVERT_CR) != 0 && b == '\r') {
int c = in.read();
if (c != -1) {
in.unread(c);
}
if (c != '\n') {
in.unread('\n');
}
} else if ((flags & CONVERT_LF) != 0 && b == '\n' && previous != '\r') {
b = '\r';
in.unread('\n');
}
previous = b;
return b;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MaxLineLimitException.java0000644 0000000 0000000 00000003045 11702050536 031634 0 ustar root root /****************************************************************
* 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.io;
import java.io.IOException;
/**
* Signals an I/O error due to a line exceeding the limit on the maximum line
* length.
*/
public class MaxLineLimitException extends IOException {
private static final long serialVersionUID = 1855987166990764426L;
public MaxLineLimitException(final String message) {
super(message);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/LineNumberInputStream.java0000644 0000000 0000000 00000004440 11702050536 031655 0 ustar root root /****************************************************************
* 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.io;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* InputStream used by the parser to wrap the original user
* supplied stream. This stream keeps track of the current line number.
*/
public class LineNumberInputStream extends FilterInputStream implements
LineNumberSource {
private int lineNumber = 1;
/**
* Creates a new LineNumberInputStream.
*
* @param is
* the stream to read from.
*/
public LineNumberInputStream(InputStream is) {
super(is);
}
public int getLineNumber() {
return lineNumber;
}
@Override
public int read() throws IOException {
int b = in.read();
if (b == '\n') {
lineNumber++;
}
return b;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
int n = in.read(b, off, len);
for (int i = off; i < off + n; i++) {
if (b[i] == '\n') {
lineNumber++;
}
}
return n;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/PositionInputStream.java 0000644 0000000 0000000 00000005137 11702050536 031425 0 ustar root root /****************************************************************
* 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.io;
import java.io.FilterInputStream;
import java.io.InputStream;
import java.io.IOException;
public class PositionInputStream extends FilterInputStream {
protected long position = 0;
private long markedPosition = 0;
public PositionInputStream(InputStream inputStream) {
super(inputStream);
}
public long getPosition() {
return position;
}
@Override
public int available() throws IOException {
return in.available();
}
@Override
public int read() throws IOException {
int b = in.read();
if (b != -1)
position++;
return b;
}
@Override
public void close() throws IOException {
in.close();
}
@Override
public void reset() throws IOException {
in.reset();
position = markedPosition;
}
@Override
public boolean markSupported() {
return in.markSupported();
}
@Override
public void mark(int readlimit) {
in.mark(readlimit);
markedPosition = position;
}
@Override
public long skip(long n) throws IOException {
final long c = in.skip(n);
if (c > 0)
position += c;
return c;
}
@Override
public int read(byte b[], int off, int len) throws IOException {
final int c = in.read(b, off, len);
if (c > 0)
position += c;
return c;
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/BufferedLineReaderInputStream.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/BufferedLineReaderInputStr0000644 0000000 0000000 00000026320 11702050536 031670 0 ustar root root /****************************************************************
* 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.io;
import org.apache.james.mime4j.util.ByteArrayBuffer;
import java.io.IOException;
import java.io.InputStream;
/**
* Input buffer that can be used to search for patterns using Quick Search
* algorithm in data read from an {@link InputStream}.
*/
public class BufferedLineReaderInputStream extends LineReaderInputStream {
private boolean truncated;
boolean tempBuffer = false;
private byte[] origBuffer;
private int origBufpos;
private int origBuflen;
private byte[] buffer;
private int bufpos;
private int buflen;
private final int maxLineLen;
public BufferedLineReaderInputStream(
final InputStream instream,
int buffersize,
int maxLineLen) {
super(instream);
if (instream == null) {
throw new IllegalArgumentException("Input stream may not be null");
}
if (buffersize <= 0) {
throw new IllegalArgumentException("Buffer size may not be negative or zero");
}
this.buffer = new byte[buffersize];
this.bufpos = 0;
this.buflen = 0;
this.maxLineLen = maxLineLen;
this.truncated = false;
}
public BufferedLineReaderInputStream(
final InputStream instream,
int buffersize) {
this(instream, buffersize, -1);
}
private void expand(int newlen) {
byte newbuffer[] = new byte[newlen];
int len = bufferLen();
if (len > 0) {
System.arraycopy(this.buffer, this.bufpos, newbuffer, this.bufpos, len);
}
this.buffer = newbuffer;
}
public void ensureCapacity(int len) {
if (len > this.buffer.length) {
expand(len);
}
}
public int fillBuffer() throws IOException {
if (tempBuffer) {
// we was on tempBuffer.
// check that we completed the tempBuffer
if (bufpos != buflen) throw new IllegalStateException("unread only works when a buffer is fully read before the next refill is asked!");
// restore the original buffer
buffer = origBuffer;
buflen = origBuflen;
bufpos = origBufpos;
tempBuffer = false;
// return that we just read bufferLen data.
return bufferLen();
}
// compact the buffer if necessary
if (this.bufpos > 0) { // could swtich to (this.buffer.length / 2) but needs a 4*boundary capacity, then (instead of 2).
int len = bufferLen();
if (len > 0) {
System.arraycopy(this.buffer, this.bufpos, this.buffer, 0, len);
}
this.bufpos = 0;
this.buflen = len;
}
int l;
int off = this.buflen;
int len = this.buffer.length - off;
l = in.read(this.buffer, off, len);
if (l == -1) {
return -1;
} else {
this.buflen = off + l;
return l;
}
}
private int bufferLen() {
return this.buflen - this.bufpos;
}
public boolean hasBufferedData() {
return bufferLen() > 0;
}
public void truncate() {
clear();
this.truncated = true;
}
protected boolean readAllowed() {
return !this.truncated;
}
@Override
public int read() throws IOException {
if (!readAllowed()) return -1;
int noRead = 0;
while (!hasBufferedData()) {
noRead = fillBuffer();
if (noRead == -1) {
return -1;
}
}
return this.buffer[this.bufpos++] & 0xff;
}
@Override
public int read(final byte[] b, int off, int len) throws IOException {
if (!readAllowed()) return -1;
if (b == null) {
return 0;
}
int noRead = 0;
while (!hasBufferedData()) {
noRead = fillBuffer();
if (noRead == -1) {
return -1;
}
}
int chunk = bufferLen();
if (chunk > len) {
chunk = len;
}
System.arraycopy(this.buffer, this.bufpos, b, off, chunk);
this.bufpos += chunk;
return chunk;
}
@Override
public int read(final byte[] b) throws IOException {
if (!readAllowed()) return -1;
if (b == null) {
return 0;
}
return read(b, 0, b.length);
}
@Override
public boolean markSupported() {
return false;
}
@Override
public int readLine(final ByteArrayBuffer dst)
throws MaxLineLimitException, IOException {
if (dst == null) {
throw new IllegalArgumentException("Buffer may not be null");
}
if (!readAllowed()) return -1;
int total = 0;
boolean found = false;
int bytesRead = 0;
while (!found) {
if (!hasBufferedData()) {
bytesRead = fillBuffer();
if (bytesRead == -1) {
break;
}
}
int i = indexOf((byte)'\n');
int chunk;
if (i != -1) {
found = true;
chunk = i + 1 - pos();
} else {
chunk = length();
}
if (chunk > 0) {
dst.append(buf(), pos(), chunk);
skip(chunk);
total += chunk;
}
if (this.maxLineLen > 0 && dst.length() >= this.maxLineLen) {
throw new MaxLineLimitException("Maximum line length limit exceeded");
}
}
if (total == 0 && bytesRead == -1) {
return -1;
} else {
return total;
}
}
/**
* Implements quick search algorithm as published by
* InputStream used by the MIME parser to detect whether the
* underlying data stream was used (read from) and whether the end of the
* stream was reached.
*/
public class LineReaderInputStreamAdaptor extends LineReaderInputStream {
private final LineReaderInputStream bis;
private final int maxLineLen;
private boolean used = false;
private boolean eof = false;
public LineReaderInputStreamAdaptor(
final InputStream is,
int maxLineLen) {
super(is);
if (is instanceof LineReaderInputStream) {
this.bis = (LineReaderInputStream) is;
} else {
this.bis = null;
}
this.maxLineLen = maxLineLen;
}
public LineReaderInputStreamAdaptor(
final InputStream is) {
this(is, -1);
}
@Override
public int read() throws IOException {
int i = in.read();
this.eof = i == -1;
this.used = true;
return i;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
int i = in.read(b, off, len);
this.eof = i == -1;
this.used = true;
return i;
}
@Override
public int readLine(final ByteArrayBuffer dst)
throws MaxLineLimitException, IOException {
int i;
if (this.bis != null) {
i = this.bis.readLine(dst);
} else {
i = doReadLine(dst);
}
this.eof = i == -1;
this.used = true;
return i;
}
private int doReadLine(final ByteArrayBuffer dst)
throws MaxLineLimitException, IOException {
int total = 0;
int ch;
while ((ch = in.read()) != -1) {
dst.append(ch);
total++;
if (this.maxLineLen > 0 && dst.length() >= this.maxLineLen) {
throw new MaxLineLimitException("Maximum line length limit exceeded");
}
if (ch == '\n') {
break;
}
}
if (total == 0 && ch == -1) {
return -1;
} else {
return total;
}
}
public boolean eof() {
return this.eof;
}
public boolean isUsed() {
return this.used;
}
@Override
public String toString() {
return "[LineReaderInputStreamAdaptor: " + bis + "]";
}
@Override
public boolean unread(ByteArrayBuffer buf) {
if (bis != null) {
return bis.unread(buf);
} else {
return false;
}
}
@Override
public long skip(long count) throws IOException {
if (count <= 0) {
return 0; // So specified by InputStream.skip(long).
}
final int bufferSize = count > 8192 ? 8192 : (int) count;
final byte[] buffer = new byte[bufferSize];
long result = 0;
while (count > 0) {
int res = read(buffer);
if (res == -1) {
break;
}
result += res;
count -= res;
}
return result;
}
}
././@LongLink 0000000 0000000 0000000 00000000155 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MaxHeaderLengthLimitException.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MaxHeaderLengthLimitExcept0000644 0000000 0000000 00000003103 11702050536 031644 0 ustar root root /****************************************************************
* 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.io;
import org.apache.james.mime4j.MimeException;
/**
* Signals a I/O error due to the total header length exceeding the maximum limit.
*/
public class MaxHeaderLengthLimitException extends MimeException {
private static final long serialVersionUID = 8924290744274769913L;
public MaxHeaderLengthLimitException(final String message) {
super(message);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MimeBoundaryInputStream.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MimeBoundaryInputStream.ja0000644 0000000 0000000 00000025310 11702050536 031660 0 ustar root root /****************************************************************
* 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.io;
import org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.MimeIOException;
import org.apache.james.mime4j.util.ByteArrayBuffer;
import org.apache.james.mime4j.util.CharsetUtil;
import java.io.IOException;
/**
* Stream that constrains itself to a single MIME body part.
* After the stream ends (i.e. read() returns -1) {@link #isLastPart()}
* can be used to determine if a final boundary has been seen or not.
*/
public class MimeBoundaryInputStream extends LineReaderInputStream {
private final byte[] boundary;
private final boolean strict;
private boolean eof;
private int limit;
private boolean atBoundary;
private int boundaryLen;
private boolean lastPart;
private boolean completed;
private BufferedLineReaderInputStream buffer;
/**
* Store the first buffer length.
* Used to distinguish between an empty preamble and
* no preamble.
*/
private int initialLength;
/**
* Creates a new MimeBoundaryInputStream.
*
* @param inbuffer The underlying stream.
* @param boundary Boundary string (not including leading hyphens).
* @throws IllegalArgumentException when boundary is too long
*/
public MimeBoundaryInputStream(
final BufferedLineReaderInputStream inbuffer,
final String boundary,
final boolean strict) throws IOException {
super(inbuffer);
int bufferSize = 2 * boundary.length();
if (bufferSize < 4096) {
bufferSize = 4096;
}
inbuffer.ensureCapacity(bufferSize);
this.buffer = inbuffer;
this.eof = false;
this.limit = -1;
this.atBoundary = false;
this.boundaryLen = 0;
this.lastPart = false;
this.initialLength = -1;
this.completed = false;
this.strict = strict;
this.boundary = new byte[boundary.length() + 2];
this.boundary[0] = (byte) '-';
this.boundary[1] = (byte) '-';
for (int i = 0; i < boundary.length(); i++) {
byte ch = (byte) boundary.charAt(i);
this.boundary[i + 2] = ch;
}
fillBuffer();
}
/**
* Creates a new MimeBoundaryInputStream.
*
* @param inbuffer The underlying stream.
* @param boundary Boundary string (not including leading hyphens).
* @throws IllegalArgumentException when boundary is too long
*/
public MimeBoundaryInputStream(
final BufferedLineReaderInputStream inbuffer,
final String boundary) throws IOException {
this(inbuffer, boundary, false);
}
/**
* Closes the underlying stream.
*
* @throws IOException on I/O errors.
*/
@Override
public void close() throws IOException {
}
/**
* @see java.io.InputStream#markSupported()
*/
@Override
public boolean markSupported() {
return false;
}
public boolean readAllowed() throws IOException {
if (completed) {
return false;
}
if (endOfStream() && !hasData()) {
skipBoundary();
verifyEndOfStream();
return false;
}
return true;
}
/**
* @see java.io.InputStream#read()
*/
@Override
public int read() throws IOException {
for (;;) {
if (!readAllowed()) return -1;
if (hasData()) {
return buffer.read();
}
fillBuffer();
}
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
for (;;) {
if (!readAllowed()) return -1;
if (hasData()) {
int chunk = Math.min(len, limit - buffer.pos());
return buffer.read(b, off, chunk);
}
fillBuffer();
}
}
@Override
public int readLine(final ByteArrayBuffer dst) throws IOException {
if (dst == null) {
throw new IllegalArgumentException("Destination buffer may not be null");
}
if (!readAllowed()) return -1;
int total = 0;
boolean found = false;
int bytesRead = 0;
while (!found) {
if (!hasData()) {
bytesRead = fillBuffer();
if (endOfStream() && !hasData()) {
skipBoundary();
verifyEndOfStream();
bytesRead = -1;
break;
}
}
int len = this.limit - this.buffer.pos();
int i = this.buffer.indexOf((byte)'\n', this.buffer.pos(), len);
int chunk;
if (i != -1) {
found = true;
chunk = i + 1 - this.buffer.pos();
} else {
chunk = len;
}
if (chunk > 0) {
dst.append(this.buffer.buf(), this.buffer.pos(), chunk);
this.buffer.skip(chunk);
total += chunk;
}
}
if (total == 0 && bytesRead == -1) {
return -1;
} else {
return total;
}
}
private void verifyEndOfStream() throws IOException {
if (strict && eof && !atBoundary) {
throw new MimeIOException(new MimeException("Unexpected end of stream"));
}
}
private boolean endOfStream() {
return eof || atBoundary;
}
private boolean hasData() {
return limit > buffer.pos() && limit <= buffer.limit();
}
private int fillBuffer() throws IOException {
if (eof) {
return -1;
}
int bytesRead;
if (!hasData()) {
bytesRead = buffer.fillBuffer();
if (bytesRead == -1) {
eof = true;
}
} else {
bytesRead = 0;
}
int i;
int off = buffer.pos();
for (;;) {
i = buffer.indexOf(boundary, off, buffer.limit() - off);
if (i == -1) {
break;
}
// Make sure the boundary is either at the very beginning of the buffer
// or preceded with LF
if (i == buffer.pos() || buffer.byteAt(i - 1) == '\n') {
int pos = i + boundary.length;
int remaining = buffer.limit() - pos;
if (remaining <= 0) {
// Make sure the boundary is terminated with EOS
break;
} else {
// or with a whitespace or '-' char
char ch = (char)(buffer.byteAt(pos));
if (CharsetUtil.isWhitespace(ch) || ch == '-') {
break;
}
}
}
off = i + boundary.length;
}
if (i != -1) {
limit = i;
atBoundary = true;
calculateBoundaryLen();
} else {
if (eof) {
limit = buffer.limit();
} else {
limit = buffer.limit() - (boundary.length + 2);
// [LF] [boundary] [CR][LF] minus one char
}
}
return bytesRead;
}
public boolean isEmptyStream() {
return initialLength == 0;
}
public boolean isFullyConsumed() {
return completed && !buffer.hasBufferedData();
}
private void calculateBoundaryLen() throws IOException {
boundaryLen = boundary.length;
int len = limit - buffer.pos();
if (len >= 0 && initialLength == -1) initialLength = len;
if (len > 0) {
if (buffer.byteAt(limit - 1) == '\n') {
boundaryLen++;
limit--;
}
}
if (len > 1) {
if (buffer.byteAt(limit - 1) == '\r') {
boundaryLen++;
limit--;
}
}
}
private void skipBoundary() throws IOException {
if (!completed) {
completed = true;
buffer.skip(boundaryLen);
boolean checkForLastPart = true;
for (;;) {
if (buffer.length() > 1) {
int ch1 = buffer.byteAt(buffer.pos());
int ch2 = buffer.byteAt(buffer.pos() + 1);
if (checkForLastPart) if (ch1 == '-' && ch2 == '-') {
this.lastPart = true;
buffer.skip(2);
checkForLastPart = false;
continue;
}
if (ch1 == '\r' && ch2 == '\n') {
buffer.skip(2);
break;
} else if (ch1 == '\n') {
buffer.skip(1);
break;
} else {
// ignoring everything in a line starting with a boundary.
buffer.skip(1);
}
} else {
if (eof) {
break;
}
fillBuffer();
}
}
}
}
public boolean isLastPart() {
return lastPart;
}
public boolean eof() {
return eof && !buffer.hasBufferedData();
}
@Override
public String toString() {
final StringBuilder buffer = new StringBuilder("MimeBoundaryInputStream, boundary ");
for (byte b : boundary) {
buffer.append((char) b);
}
return buffer.toString();
}
@Override
public boolean unread(ByteArrayBuffer buf) {
return false;
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MaxHeaderLimitException.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/MaxHeaderLimitException.ja0000644 0000000 0000000 00000003060 11702050536 031603 0 ustar root root /****************************************************************
* 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.io;
import org.apache.james.mime4j.MimeException;
/**
* Signals a I/O error due to the header count exceeding the maximum limit.
*/
public class MaxHeaderLimitException extends MimeException {
private static final long serialVersionUID = 2154269045186186769L;
public MaxHeaderLimitException(final String message) {
super(message);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/LimitedInputStream.java 0000644 0000000 0000000 00000004510 11702050536 031202 0 ustar root root /****************************************************************
* 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.io;
import java.io.InputStream;
import java.io.IOException;
public class LimitedInputStream extends PositionInputStream {
private final long limit;
public LimitedInputStream(InputStream instream, long limit) {
super(instream);
if (limit < 0) {
throw new IllegalArgumentException("Limit may not be negative");
}
this.limit = limit;
}
private void enforceLimit() throws IOException {
if (position >= limit) {
throw new IOException("Input stream limit exceeded");
}
}
@Override
public int read() throws IOException {
enforceLimit();
return super.read();
}
@Override
public int read(byte b[], int off, int len) throws IOException {
enforceLimit();
len = Math.min(len, getBytesLeft());
return super.read(b, off, len);
}
@Override
public long skip(long n) throws IOException {
enforceLimit();
n = Math.min(n, getBytesLeft());
return super.skip(n);
}
private int getBytesLeft() {
return (int)Math.min(Integer.MAX_VALUE, limit - position);
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/LineNumberSource.java 0000644 0000000 0000000 00000002670 11702050536 030645 0 ustar root root /****************************************************************
* 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.io;
public interface LineNumberSource {
/**
* Gets the current line number starting at 1 (the number of
* \r\n read so far plus 1).
*
* @return the current line number.
*/
int getLineNumber();
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/io/LineReaderInputStream.java0000644 0000000 0000000 00000005012 11702050536 031623 0 ustar root root /****************************************************************
* 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.io;
import org.apache.james.mime4j.util.ByteArrayBuffer;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* Input stream capable of reading lines of text.
*/
public abstract class LineReaderInputStream extends FilterInputStream {
protected LineReaderInputStream(InputStream in) {
super(in);
}
/**
* Reads one line of text into the given {@link ByteArrayBuffer}.
*
* @param dst Destination
* @return number of bytes copied or -1 if the end of
* the stream has been reached.
*
* @throws MaxLineLimitException if the line exceeds a limit on
* the line length imposed by a subclass.
* @throws IOException in case of an I/O error.
*/
public abstract int readLine(final ByteArrayBuffer dst)
throws MaxLineLimitException, IOException;
/**
* Tries to unread the last read line.
*
* Implementation may refuse to unread a new buffer until the previous
* unread one has been competely consumed.
*
* Implementations will directly use the byte array backed by buf, so
* make sure to not alter it anymore once this method has been called.
*
* @return true if the unread has been succesfull.
*/
public abstract boolean unread(ByteArrayBuffer buf);
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/ 0000755 0000000 0000000 00000000000 11702050540 025433 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/MimeConfig.java 0000644 0000000 0000000 00000022067 11702050540 030322 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.MimeException;
/**
* Properties used to configure the behavior of MIME stream parsers.
*/
public final class MimeConfig implements Cloneable {
private boolean strictParsing;
private int maxLineLen;
private int maxHeaderCount;
private int maxHeaderLen;
private long maxContentLen;
private boolean countLineNumbers;
private String headlessParsing;
private boolean malformedHeaderStartsBody;
public MimeConfig() {
this.strictParsing = false;
this.countLineNumbers = false;
this.malformedHeaderStartsBody = false;
this.maxLineLen = 1000;
this.maxHeaderCount = 1000;
this.maxHeaderLen = 10000;
this.maxContentLen = -1;
this.headlessParsing = null;
}
/**
* @see #setMalformedHeaderStartsBody(boolean)
*
* @return true if malformed header should "end" the headers and be part of
* the body
*/
public boolean isMalformedHeaderStartsBody() {
return malformedHeaderStartsBody;
}
/**
* Define the behaviour for dealing with malformed headers while in lenient
* mode
*
* @param malformedHeaderStartsBody
* true to make the parser interpret a malformed
* header as end of the headers and as part of the body (as if
* the CRLF separator was missing). false to simply
* ignore malformed headers and continue parsing headers from the
* following line.
*/
public void setMalformedHeaderStartsBody(boolean malformedHeaderStartsBody) {
this.malformedHeaderStartsBody = malformedHeaderStartsBody;
}
/**
* Returns the value of the strict parsing mode
*
* @see #setStrictParsing(boolean)
*
* @return value of the strict parsing mode
*/
public boolean isStrictParsing() {
return this.strictParsing;
}
/**
* Defines whether minor violations of the MIME specification should be
* tolerated or should result in a {@link MimeException}. If this parameter
* is set to true, a strict interpretation of the MIME
* specification will be enforced, If this parameter is set to
* false minor violations will result in a warning in the log.
* false
*
* @param strictParsing
* value of the strict parsing mode
*/
public void setStrictParsing(boolean strictParsing) {
this.strictParsing = strictParsing;
}
/**
* Returns the maximum line length limit
*
* @see #setMaxLineLen(int)
*
* @return value of the the maximum line length limit
*/
public int getMaxLineLen() {
return this.maxLineLen;
}
/**
* Sets the maximum line length limit. Parsing of a MIME entity will be
* terminated with a {@link MimeException} if a line is encountered that
* exceeds the maximum length limit. If this parameter is set to a non
* positive value the line length check will be disabled.
* 1000
*
* @param maxLineLen
* maximum line length limit
*/
public void setMaxLineLen(int maxLineLen) {
this.maxLineLen = maxLineLen;
}
/**
* Returns the maximum header limit
*
* @see #setMaxHeaderCount(int)
*
* @return value of the the maximum header limit
*/
public int getMaxHeaderCount() {
return this.maxHeaderCount;
}
/**
* Sets the maximum header limit. Parsing of a MIME entity will be
* terminated with a {@link MimeException} if the number of headers exceeds
* the maximum limit. If this parameter is set to a non positive value the
* header limit check will be disabled.
* 1000
*
* @param maxHeaderCount
* maximum header limit
*/
public void setMaxHeaderCount(int maxHeaderCount) {
this.maxHeaderCount = maxHeaderCount;
}
/**
* Returns the maximum header length limit
*
* @see #setMaxHeaderLen(int)
*
* @return value of the maximum header length limit
*/
public int getMaxHeaderLen() {
return maxHeaderLen;
}
/**
* Sets the maximum header length limit. Parsing of a MIME entity will be
* terminated with a {@link MimeException} if the total length of a header
* exceeds this limit. If this parameter is set to a non positive value the
* header length check will be disabled.
* 10000
*
* @param maxHeaderLen
* maximum header length limit
*/
public void setMaxHeaderLen(int maxHeaderLen) {
this.maxHeaderLen = maxHeaderLen;
}
/**
* Returns the maximum content length limit
*
* @see #setMaxContentLen(long)
*
* @return value of the the maximum content length limit
*/
public long getMaxContentLen() {
return maxContentLen;
}
/**
* Sets the maximum content length limit. Parsing of a MIME entity will be
* terminated with a {@link MimeException} if a content body exceeds the
* maximum length limit. If this parameter is set to a non positive value
* the content length check will be disabled.
* -1
*
* @param maxContentLen
* maximum content length limit
*/
public void setMaxContentLen(long maxContentLen) {
this.maxContentLen = maxContentLen;
}
/**
* Returns the value of the line number counting mode.
*
* @return value of the line number counting mode.
*/
public boolean isCountLineNumbers() {
return countLineNumbers;
}
/**
* Defines whether the parser should count line numbers. If enabled line
* numbers are included in the debug output.
* false
*
* @param countLineNumbers
* value of the line number counting mode.
*/
public void setCountLineNumbers(boolean countLineNumbers) {
this.countLineNumbers = countLineNumbers;
}
/**
* Returns the value of the default content type. When not null, indicates
* that the parsing should be headless.
*
* @return default content type when parsing headless, null otherwise
* @see org.apache.james.mime4j.parser.MimeStreamParser#parse(java.io.InputStream)
*/
public String getHeadlessParsing() {
return headlessParsing;
}
/**
* Defines a default content type. When not null, indicates that the parsing
* should be headless.
* null
*
* @param contentType
* value of the default content type when parsing headless, null
* otherwise
* @see org.apache.james.mime4j.parser.MimeStreamParser#parse(java.io.InputStream)
*/
public void setHeadlessParsing(String contentType) {
this.headlessParsing = contentType;
}
@Override
public MimeConfig clone() {
try {
return (MimeConfig) super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
@Override
public String toString() {
return "[strict parsing: " + strictParsing + ", max line length: " + maxLineLen + ", max header count: " + maxHeaderCount + ", max content length: " + maxContentLen + ", count line numbers: " + countLineNumbers + "]";
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/EntityStateMachine.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/EntityStateMachine.jav0000644 0000000 0000000 00000007714 11702050540 031710 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.MimeException;
import java.io.IOException;
import java.io.InputStream;
/**
* Represents the interal state of a MIME entity, which is being retrieved
* from an input stream by a MIME parser.
*/
public interface EntityStateMachine {
/**
* Return the current state of the entity.
*
* @see EntityState
*
* @return current state
*/
EntityState getState();
/**
* Sets 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 message/rfc822 part is encounted;
* {@link RecursionMode#M_NO_RECURSE} does not.
*
* @see RecursionMode
*
* @param recursionMode
*/
void setRecursionMode(RecursionMode recursionMode);
/**
* Advances the state machine to the next state in the
* process of the MIME stream parsing. This method
* may return an new state machine that represents an embedded
* entity, which must be parsed before the parsing process of
* the current entity can proceed.
*
* @return a state machine of an embedded entity, if encountered,
* null otherwise.
*
* @throws IOException if an I/O error occurs.
* @throws MimeException if the message can not be processed due
* to the MIME specification violation.
*/
EntityStateMachine advance() throws IOException, MimeException;
/**
* Returns description of the entity body.
*
* @return body description
*
* @throws IllegalStateException if the body description cannot be
* obtained at the current stage of the parsing process.
*/
BodyDescriptor getBodyDescriptor() throws IllegalStateException;
/**
* Returns content stream of the entity body.
*
* @return input stream
*
* @throws IllegalStateException if the content stream cannot be
* obtained at the current stage of the parsing process.
*/
InputStream getContentStream() throws IllegalStateException;
/**
* Returns the decoded content stream of the entity body.
*
* @return input stream
*
* @throws IllegalStateException if the content stream cannot be
* obtained at the current stage of the parsing process.
*/
InputStream getDecodedContentStream() throws IllegalStateException;
/**
* Returns current header field.
*
* @return header field
*
* @throws IllegalStateException if a header field cannot be
* obtained at the current stage of the parsing process.
*/
Field getField() throws IllegalStateException;
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/MimeTokenStream.java 0000644 0000000 0000000 00000035201 11702050540 031343 0 ustar root root /****************************************************************
* 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.nio.charset.Charset;
import java.util.LinkedList;
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.io.LineNumberSource;
import org.apache.james.mime4j.util.CharsetUtil;
/**
*
* 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();
* }
*
* true if in raw mode, false
* 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 message/rfc822 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 message/rfc822 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;
}
/**
* This method returns the raw entity, preamble, or epilogue contents.
*
* This method is valid, if {@link #getState()} returns either of
* {@link EntityState#T_RAW_ENTITY}, {@link EntityState#T_PREAMBLE}, or
* {@link EntityState#T_EPILOGUE}.
*
* @return Data stream, depending on the current state.
* @throws IllegalStateException {@link #getState()} returns an
* invalid value.
*/
public InputStream getInputStream() {
return currentStateMachine.getContentStream();
}
/**
* This method returns a transfer decoded stream based on the MIME
* fields with the standard defaults.
*
* This method is valid, if {@link #getState()} returns either of
* {@link EntityState#T_RAW_ENTITY}, {@link EntityState#T_PREAMBLE}, or
* {@link EntityState#T_EPILOGUE}.
*
* @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 Reader, not null
* @see #getInputStream
* @throws IllegalStateException {@link #getState()} returns an
* invalid value
* @throws UnsupportedCharsetException if there is no JVM support
* for decoding the charset
* @throws IllegalCharsetNameException if the charset name specified
* in the mime type is illegal
*/
public Reader getReader() {
final BodyDescriptor bodyDescriptor = getBodyDescriptor();
final String mimeCharset = bodyDescriptor.getCharset();
final Charset charset;
if (mimeCharset == null || "".equals(mimeCharset)) {
charset = CharsetUtil.US_ASCII;
} else {
charset = Charset.forName(mimeCharset);
}
final InputStream instream = getDecodedInputStream();
return new InputStreamReader(instream, charset);
}
/**
*
*
* @return BodyDescriptor, 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 final String stateToString(EntityState state) {
return MimeEntity.stateToString(state);
}
public MimeConfig getConfig() {
return config;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/RecursionMode.java 0000644 0000000 0000000 00000003221 11702050540 031052 0 ustar root root /****************************************************************
* 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;
/**
* Enumeration of parsing modes.
*/
public enum RecursionMode {
/**
* Recursively parse every message/rfc822 part
*/
M_RECURSE,
/**
* Do not recurse message/rfc822 parts
*/
M_NO_RECURSE,
/**
* Parse into raw entities
*/
M_RAW,
/**
* Do not recurse message/rfc822 parts
* and treat multiparts as a single flat body.
*/
M_FLAT
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/MimeEntity.java 0000644 0000000 0000000 00000047650 11702050540 030376 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.codec.Base64InputStream;
import org.apache.james.mime4j.codec.DecodeMonitor;
import org.apache.james.mime4j.codec.QuotedPrintableInputStream;
import org.apache.james.mime4j.io.BufferedLineReaderInputStream;
import org.apache.james.mime4j.io.LimitedInputStream;
import org.apache.james.mime4j.io.LineNumberSource;
import org.apache.james.mime4j.io.LineReaderInputStream;
import org.apache.james.mime4j.io.LineReaderInputStreamAdaptor;
import org.apache.james.mime4j.io.MaxHeaderLimitException;
import org.apache.james.mime4j.io.MaxLineLimitException;
import org.apache.james.mime4j.io.MimeBoundaryInputStream;
import org.apache.james.mime4j.util.ByteArrayBuffer;
import org.apache.james.mime4j.util.CharsetUtil;
import org.apache.james.mime4j.util.MimeUtil;
class MimeEntity implements EntityStateMachine {
private final EntityState endState;
private final MimeConfig config;
private final DecodeMonitor monitor;
private final FieldBuilder fieldBuilder;
private final BodyDescriptorBuilder bodyDescBuilder;
private final ByteArrayBuffer linebuf;
private final LineNumberSource lineSource;
private final BufferedLineReaderInputStream inbuffer;
private EntityState state;
private int lineCount;
private boolean endOfHeader;
private int headerCount;
private Field field;
private BodyDescriptor body;
private RecursionMode recursionMode;
private MimeBoundaryInputStream currentMimePartStream;
private LineReaderInputStreamAdaptor dataStream;
private byte[] tmpbuf;
MimeEntity(
LineNumberSource lineSource,
InputStream instream,
MimeConfig config,
EntityState startState,
EntityState endState,
DecodeMonitor monitor,
FieldBuilder fieldBuilder,
BodyDescriptorBuilder bodyDescBuilder) {
super();
this.config = config;
this.state = startState;
this.endState = endState;
this.monitor = monitor;
this.fieldBuilder = fieldBuilder;
this.bodyDescBuilder = bodyDescBuilder;
this.linebuf = new ByteArrayBuffer(64);
this.lineCount = 0;
this.endOfHeader = false;
this.headerCount = 0;
this.lineSource = lineSource;
this.inbuffer = new BufferedLineReaderInputStream(
instream,
4 * 1024,
config.getMaxLineLen());
this.dataStream = new LineReaderInputStreamAdaptor(
inbuffer,
config.getMaxLineLen());
}
MimeEntity(
LineNumberSource lineSource,
InputStream instream,
MimeConfig config,
EntityState startState,
EntityState endState,
BodyDescriptorBuilder bodyDescBuilder) {
this(lineSource, instream, config, startState, endState,
config.isStrictParsing() ? DecodeMonitor.STRICT : DecodeMonitor.SILENT,
new DefaultFieldBuilder(config.getMaxHeaderLen()),
bodyDescBuilder);
}
MimeEntity(
LineNumberSource lineSource,
InputStream instream,
MimeConfig config,
BodyDescriptorBuilder bodyDescBuilder) {
this(lineSource, instream, config,
EntityState.T_START_MESSAGE, EntityState.T_END_MESSAGE,
config.isStrictParsing() ? DecodeMonitor.STRICT : DecodeMonitor.SILENT,
new DefaultFieldBuilder(config.getMaxHeaderLen()),
bodyDescBuilder);
}
MimeEntity(
LineNumberSource lineSource,
InputStream instream,
FieldBuilder fieldBuilder,
BodyDescriptorBuilder bodyDescBuilder) {
this(lineSource, instream, new MimeConfig(),
EntityState.T_START_MESSAGE, EntityState.T_END_MESSAGE,
DecodeMonitor.SILENT,
fieldBuilder,
bodyDescBuilder);
}
MimeEntity(
LineNumberSource lineSource,
InputStream instream,
BodyDescriptorBuilder bodyDescBuilder) {
this(lineSource, instream, new MimeConfig(),
EntityState.T_START_MESSAGE, EntityState.T_END_MESSAGE,
DecodeMonitor.SILENT,
new DefaultFieldBuilder(-1),
bodyDescBuilder);
}
public EntityState getState() {
return state;
}
public RecursionMode getRecursionMode() {
return recursionMode;
}
public void setRecursionMode(RecursionMode recursionMode) {
this.recursionMode = recursionMode;
}
public void stop() {
this.inbuffer.truncate();
}
private int getLineNumber() {
if (lineSource == null)
return -1;
else
return lineSource.getLineNumber();
}
private LineReaderInputStream getDataStream() {
return dataStream;
}
/**
* Creates an indicative message suitable for display
* based on the given event and the current state of the system.
* @param event Event, not null
* @return message suitable for use as a message in an exception
* or for logging
*/
protected String message(Event event) {
final String message;
if (event == null) {
message = "Event is unexpectedly null.";
} else {
message = event.toString();
}
int lineNumber = getLineNumber();
if (lineNumber <= 0)
return message;
else
return "Line " + lineNumber + ": " + message;
}
protected void monitor(Event event) throws MimeException, IOException {
if (monitor.isListening()) {
String message = message(event);
if (monitor.warn(message, "ignoring")) {
throw new MimeParseEventException(event);
}
}
}
private void readRawField() throws IOException, MimeException {
if (endOfHeader)
throw new IllegalStateException();
LineReaderInputStream instream = getDataStream();
try {
for (;;) {
// If there's still data stuck in the line buffer
// copy it to the field buffer
int len = linebuf.length();
if (len > 0) {
fieldBuilder.append(linebuf);
}
linebuf.clear();
if (instream.readLine(linebuf) == -1) {
monitor(Event.HEADERS_PREMATURE_END);
endOfHeader = true;
break;
}
len = linebuf.length();
if (len > 0 && linebuf.byteAt(len - 1) == '\n') {
len--;
}
if (len > 0 && linebuf.byteAt(len - 1) == '\r') {
len--;
}
if (len == 0) {
// empty line detected
endOfHeader = true;
break;
}
lineCount++;
if (lineCount > 1) {
int ch = linebuf.byteAt(0);
if (ch != CharsetUtil.SP && ch != CharsetUtil.HT) {
// new header detected
break;
}
}
}
} catch (MaxLineLimitException e) {
throw new MimeException(e);
}
}
protected boolean nextField() throws MimeException, IOException {
int maxHeaderCount = config.getMaxHeaderCount();
// the loop is here to transparently skip invalid headers
for (;;) {
if (endOfHeader) {
return false;
}
if (maxHeaderCount > 0 && headerCount >= maxHeaderCount) {
throw new MaxHeaderLimitException("Maximum header limit exceeded");
}
headerCount++;
fieldBuilder.reset();
readRawField();
try {
RawField rawfield = fieldBuilder.build();
if (rawfield == null) {
continue;
}
if (rawfield.getDelimiterIdx() != rawfield.getName().length()) {
monitor(Event.OBSOLETE_HEADER);
}
Field parsedField = bodyDescBuilder.addField(rawfield);
field = parsedField != null ? parsedField : rawfield;
return true;
} catch (MimeException e) {
monitor(Event.INVALID_HEADER);
if (config.isMalformedHeaderStartsBody()) {
LineReaderInputStream instream = getDataStream();
ByteArrayBuffer buf = fieldBuilder.getRaw();
// Complain, if raw data is not available or cannot be 'unread'
if (buf == null || !instream.unread(buf)) {
throw new MimeParseEventException(Event.INVALID_HEADER);
}
return false;
}
}
}
}
public EntityStateMachine advance() throws IOException, MimeException {
switch (state) {
case T_START_MESSAGE:
state = EntityState.T_START_HEADER;
break;
case T_START_BODYPART:
state = EntityState.T_START_HEADER;
break;
case T_START_HEADER:
bodyDescBuilder.reset();
case T_FIELD:
state = nextField() ? EntityState.T_FIELD : EntityState.T_END_HEADER;
break;
case T_END_HEADER:
body = bodyDescBuilder.build();
String mimeType = body.getMimeType();
if (recursionMode == RecursionMode.M_FLAT) {
state = EntityState.T_BODY;
} else if (MimeUtil.isMultipart(mimeType)) {
state = EntityState.T_START_MULTIPART;
clearMimePartStream();
} else if (recursionMode != RecursionMode.M_NO_RECURSE
&& MimeUtil.isMessage(mimeType)) {
state = EntityState.T_BODY;
return nextMessage();
} else {
state = EntityState.T_BODY;
}
break;
case T_START_MULTIPART:
if (dataStream.isUsed()) {
advanceToBoundary();
state = EntityState.T_END_MULTIPART;
break;
} else {
createMimePartStream();
state = EntityState.T_PREAMBLE;
boolean empty = currentMimePartStream.isEmptyStream();
if (!empty) break;
// continue to next state
}
case T_PREAMBLE:
// removed specific code. Fallback to T_IN_BODYPART that
// better handle missing parts.
// Removed the T_IN_BODYPART state (always use T_PREAMBLE)
advanceToBoundary();
if (currentMimePartStream.eof() && !currentMimePartStream.isLastPart()) {
monitor(Event.MIME_BODY_PREMATURE_END);
} else {
if (!currentMimePartStream.isLastPart()) {
clearMimePartStream();
createMimePartStream();
return nextMimeEntity();
}
}
boolean empty = currentMimePartStream.isFullyConsumed();
clearMimePartStream();
state = EntityState.T_EPILOGUE;
if (!empty) break;
// continue to next state
case T_EPILOGUE:
state = EntityState.T_END_MULTIPART;
break;
case T_BODY:
case T_END_MULTIPART:
state = endState;
break;
default:
if (state == endState) {
state = EntityState.T_END_OF_STREAM;
break;
}
throw new IllegalStateException("Invalid state: " + stateToString(state));
}
return null;
}
private void createMimePartStream() throws MimeException, IOException {
String boundary = body.getBoundary();
try {
currentMimePartStream = new MimeBoundaryInputStream(inbuffer, boundary,
config.isStrictParsing());
} catch (IllegalArgumentException e) {
// thrown when boundary is too long
throw new MimeException(e.getMessage(), e);
}
dataStream = new LineReaderInputStreamAdaptor(
currentMimePartStream,
config.getMaxLineLen());
}
private void clearMimePartStream() {
currentMimePartStream = null;
dataStream = new LineReaderInputStreamAdaptor(
inbuffer,
config.getMaxLineLen());
}
private void advanceToBoundary() throws IOException {
if (!dataStream.eof()) {
if (tmpbuf == null) {
tmpbuf = new byte[2048];
}
InputStream instream = getLimitedContentStream();
while (instream.read(tmpbuf)!= -1) {
}
}
}
private EntityStateMachine nextMessage() {
// optimize nesting of streams returning the "lower" stream instead of
// always return dataStream (that would add a LineReaderInputStreamAdaptor in the chain)
InputStream instream = currentMimePartStream != null ? currentMimePartStream : inbuffer;
instream = decodedStream(instream);
return nextMimeEntity(EntityState.T_START_MESSAGE, EntityState.T_END_MESSAGE, instream);
}
private InputStream decodedStream(InputStream instream) {
String transferEncoding = body.getTransferEncoding();
if (MimeUtil.isBase64Encoding(transferEncoding)) {
instream = new Base64InputStream(instream, monitor);
} else if (MimeUtil.isQuotedPrintableEncoded(transferEncoding)) {
instream = new QuotedPrintableInputStream(instream, monitor);
}
return instream;
}
private EntityStateMachine nextMimeEntity() {
return nextMimeEntity(EntityState.T_START_BODYPART, EntityState.T_END_BODYPART, currentMimePartStream);
}
private EntityStateMachine nextMimeEntity(EntityState startState, EntityState endState, InputStream instream) {
if (recursionMode == RecursionMode.M_RAW) {
RawEntity message = new RawEntity(instream);
return message;
} else {
MimeEntity mimeentity = new MimeEntity(
lineSource,
instream,
config,
startState,
endState,
monitor,
fieldBuilder,
bodyDescBuilder.newChild());
mimeentity.setRecursionMode(recursionMode);
return mimeentity;
}
}
private InputStream getLimitedContentStream() {
long maxContentLimit = config.getMaxContentLen();
if (maxContentLimit >= 0) {
return new LimitedInputStream(dataStream, maxContentLimit);
} else {
return dataStream;
}
}
/**
*
*
* @return BodyDescriptor, not nulls
*/
public BodyDescriptor getBodyDescriptor() {
switch (getState()) {
case T_BODY:
case T_START_MULTIPART:
case T_PREAMBLE:
case T_EPILOGUE:
case T_END_OF_STREAM:
return body;
default:
throw new IllegalStateException("Invalid state :" + stateToString(state));
}
}
/**
* 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() {
switch (getState()) {
case T_FIELD:
return field;
default:
throw new IllegalStateException("Invalid state :" + stateToString(state));
}
}
/**
* @see org.apache.james.mime4j.stream.EntityStateMachine#getContentStream()
*/
public InputStream getContentStream() {
switch (state) {
case T_START_MULTIPART:
case T_PREAMBLE:
case T_EPILOGUE:
case T_BODY:
return getLimitedContentStream();
default:
throw new IllegalStateException("Invalid state: " + stateToString(state));
}
}
/**
* @see org.apache.james.mime4j.stream.EntityStateMachine#getDecodedContentStream()
*/
public InputStream getDecodedContentStream() throws IllegalStateException {
return decodedStream(getContentStream());
}
@Override
public String toString() {
return getClass().getName() + " [" + stateToString(state)
+ "][" + body.getMimeType() + "][" + body.getBoundary() + "]";
}
/**
* Renders a state as a string suitable for logging.
* @param state
* @return rendered as string, not null
*/
public static final String stateToString(EntityState state) {
final String result;
switch (state) {
case T_END_OF_STREAM:
result = "End of stream";
break;
case T_START_MESSAGE:
result = "Start message";
break;
case T_END_MESSAGE:
result = "End message";
break;
case T_RAW_ENTITY:
result = "Raw entity";
break;
case T_START_HEADER:
result = "Start header";
break;
case T_FIELD:
result = "Field";
break;
case T_END_HEADER:
result = "End header";
break;
case T_START_MULTIPART:
result = "Start multipart";
break;
case T_END_MULTIPART:
result = "End multipart";
break;
case T_PREAMBLE:
result = "Preamble";
break;
case T_EPILOGUE:
result = "Epilogue";
break;
case T_START_BODYPART:
result = "Start bodypart";
break;
case T_END_BODYPART:
result = "End bodypart";
break;
case T_BODY:
result = "Body";
break;
default:
result = "Unknown";
break;
}
return result;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/ContentDescriptor.java0000644 0000000 0000000 00000006277 11702050540 031763 0 ustar root root /****************************************************************
* 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;
/**
* A descriptor containing common MIME content properties.
*/
public interface ContentDescriptor {
/**
* Returns the body descriptors MIME type.
* @see #getMediaType()
* @see #getSubType()
* @return The MIME type, which has been parsed from the
* content-type definition. Must not be null, but
* "text/plain", if no content-type was specified.
*/
String getMimeType();
/**
* Gets the defaulted MIME media type for this content.
* For example TEXT, IMAGE, MULTIPART
* @see #getMimeType()
* @return the MIME media type when content-type specified,
* otherwise the correct default (TEXT)
*/
String getMediaType();
/**
* Gets the defaulted MIME sub type for this content.
* @see #getMimeType()
* @return the MIME media type when content-type is specified,
* otherwise the correct default (PLAIN)
*/
String getSubType();
/**
* TEXT types, this will be defaulted to us-ascii.
* For other types, when the charset parameter is missing this property will be null.
* TEXT types, when unset will
* be set to default us-ascii. For other types, when unset,
* null will be returned.
*/
String getCharset();
/**
* Returns the body descriptors transfer encoding.
* @return The transfer encoding. Must not be null, but "7bit",
* if no transfer-encoding was specified.
*/
String getTransferEncoding();
/**
* Returns the body descriptors content-length.
* @return Content length, if known, or -1, to indicate the absence of a
* content-length header.
*/
long getContentLength();
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/FallbackBodyDescriptorBuilder.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/FallbackBodyDescriptor0000644 0000000 0000000 00000017162 11702050540 031741 0 ustar root root /****************************************************************
* 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.util.HashMap;
import java.util.Locale;
import java.util.Map;
import org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.codec.DecodeMonitor;
import org.apache.james.mime4j.util.MimeUtil;
/**
* Encapsulates the values of the MIME-specific header fields
* (which starts with Content-).
*/
class FallbackBodyDescriptorBuilder implements BodyDescriptorBuilder {
private static final String US_ASCII = "us-ascii";
private static final String SUB_TYPE_EMAIL = "rfc822";
private static final String MEDIA_TYPE_TEXT = "text";
private static final String MEDIA_TYPE_MESSAGE = "message";
private static final String EMAIL_MESSAGE_MIME_TYPE = MEDIA_TYPE_MESSAGE + "/" + SUB_TYPE_EMAIL;
private static final String DEFAULT_SUB_TYPE = "plain";
private static final String DEFAULT_MEDIA_TYPE = MEDIA_TYPE_TEXT;
private static final String DEFAULT_MIME_TYPE = DEFAULT_MEDIA_TYPE + "/" + DEFAULT_SUB_TYPE;
private final String parentMimeType;
private final DecodeMonitor monitor;
private String mediaType;
private String subType;
private String mimeType;
private String boundary;
private String charset;
private String transferEncoding;
private long contentLength;
/**
* Creates a new root BodyDescriptor instance.
*/
public FallbackBodyDescriptorBuilder() {
this(null, null);
}
/**
* Creates a new BodyDescriptor instance.
*
* @param parent the descriptor of the parent or null if this
* is the root descriptor.
*/
public FallbackBodyDescriptorBuilder(final String parentMimeType, final DecodeMonitor monitor) {
super();
this.parentMimeType = parentMimeType;
this.monitor = monitor != null ? monitor : DecodeMonitor.SILENT;
reset();
}
public void reset() {
mimeType = null;
subType = null;
mediaType = null;
boundary = null;
charset = null;
transferEncoding = null;
contentLength = -1;
}
public BodyDescriptorBuilder newChild() {
return new FallbackBodyDescriptorBuilder(mimeType, monitor);
}
public BodyDescriptor build() {
String actualMimeType = mimeType;
String actualMediaType = mediaType;
String actualSubType = subType;
String actualCharset = charset;
if (actualMimeType == null) {
if (MimeUtil.isSameMimeType("multipart/digest", parentMimeType)) {
actualMimeType = EMAIL_MESSAGE_MIME_TYPE;
actualMediaType = MEDIA_TYPE_MESSAGE;
actualSubType = SUB_TYPE_EMAIL;
} else {
actualMimeType = DEFAULT_MIME_TYPE;
actualMediaType = DEFAULT_MEDIA_TYPE;
actualSubType = DEFAULT_SUB_TYPE;
}
}
if (actualCharset == null && MEDIA_TYPE_TEXT.equals(actualMediaType)) {
actualCharset = US_ASCII;
}
return new BasicBodyDescriptor(actualMimeType, actualMediaType, actualSubType,
boundary, actualCharset,
transferEncoding != null ? transferEncoding : "7bit",
contentLength);
}
/**
* Should be called for each Content- header field of
* a MIME message or part.
*
* @param field the MIME field.
*/
public Field addField(RawField field) throws MimeException {
String name = field.getName().toLowerCase(Locale.US);
if (name.equals("content-transfer-encoding") && transferEncoding == null) {
String value = field.getBody();
if (value != null) {
value = value.trim().toLowerCase(Locale.US);
if (value.length() > 0) {
transferEncoding = value;
}
}
} else if (name.equals("content-length") && contentLength == -1) {
String value = field.getBody();
if (value != null) {
value = value.trim();
try {
contentLength = Long.parseLong(value.trim());
} catch (NumberFormatException e) {
if (monitor.warn("Invalid content length: " + value,
"ignoring Content-Length header")) {
throw new MimeException("Invalid Content-Length header: " + value);
}
}
}
} else if (name.equals("content-type") && mimeType == null) {
parseContentType(field);
}
return null;
}
private void parseContentType(Field field) throws MimeException {
RawField rawfield;
if (field instanceof RawField) {
rawfield = ((RawField) field);
} else {
rawfield = new RawField(field.getName(), field.getBody());
}
RawBody body = RawFieldParser.DEFAULT.parseRawBody(rawfield);
String main = body.getValue();
Map
*
*/
public interface BodyDescriptorBuilder {
/**
* Resets the internal state of the builder making it ready to process new input.
*/
void reset();
/**
* Updates builder's internal state by adding a new field. The builder can optionally
* transform the unstructured field given an an input into a structured one and return
* an instance {@link Field} that also implements a richer interface for a particular type
* of fields such as Content-Type. The builder can also return null
* if the field is to be ignoredContent-Type. The builder can also return null
* if the field is to be ignored.
*/
Field addField(RawField field) throws MimeException;
/**
* Builds an instance of {@link BodyDescriptor} based on the internal state.
*/
BodyDescriptor build();
/**
* Creates an instance of {@link BodyDescriptorBuilder} to be used for processing of an
* embedded content body. Please the child instance can inherit some of its parent properties
* such as MIME type.
*/
BodyDescriptorBuilder newChild();
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/NameValuePair.java 0000644 0000000 0000000 00000005301 11702050540 030766 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.util.LangUtils;
/**
* A name / value tuple
*/
public final class NameValuePair {
private final String name;
private final String value;
public NameValuePair(final String name, final String value) {
super();
if (name == null) {
throw new IllegalArgumentException("Name may not be null");
}
this.name = name;
this.value = value;
}
public String getName() {
return this.name;
}
public String getValue() {
return this.value;
}
public String toString() {
if (this.value == null) {
return name;
} else {
StringBuilder buffer = new StringBuilder();
buffer.append(this.name);
buffer.append("=");
buffer.append("\"");
buffer.append(this.value);
buffer.append("\"");
return buffer.toString();
}
}
public boolean equals(final Object object) {
if (this == object) return true;
if (object instanceof NameValuePair) {
NameValuePair that = (NameValuePair) object;
return this.name.equals(that.name)
&& LangUtils.equals(this.value, that.value);
} else {
return false;
}
}
public int hashCode() {
int hash = LangUtils.HASH_SEED;
hash = LangUtils.hashCode(hash, this.name);
hash = LangUtils.hashCode(hash, this.value);
return hash;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/RawField.java 0000644 0000000 0000000 00000006257 11702050540 030005 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.util.ByteSequence;
import org.apache.james.mime4j.util.CharsetUtil;
import org.apache.james.mime4j.util.ContentUtil;
import org.apache.james.mime4j.util.MimeUtil;
/**
* Raw (unstructured) MIME field. The field's body is unparsed and possibly encoded.
*
* Instances of this class can be created by using
* {@link RawFieldParser#parseField(ByteSequence)} method.
*/
public final class RawField implements Field {
private final ByteSequence raw;
private final int delimiterIdx;
private final String name;
private final String body;
RawField(ByteSequence raw, int delimiterIdx, String name, String body) {
if (name == null) {
throw new IllegalArgumentException("Field may not be null");
}
this.raw = raw;
this.delimiterIdx = delimiterIdx;
this.name = name.trim();
this.body = body;
}
public RawField(String name, String body) {
this(null, -1, name, body);
}
public ByteSequence getRaw() {
return raw;
}
public String getName() {
return name;
}
public String getBody() {
if (body != null) {
return body;
}
if (raw != null) {
int len = raw.length();
int off = delimiterIdx + 1;
if (len > off + 1 && (CharsetUtil.isWhitespace((char) (raw.byteAt(off) & 0xff)))) {
off++;
}
return MimeUtil.unfold(ContentUtil.decode(raw, off, len - off));
}
return null;
}
public int getDelimiterIdx() {
return delimiterIdx;
}
@Override
public String toString() {
if (raw != null) {
return ContentUtil.decode(raw);
} else {
StringBuilder buf = new StringBuilder();
buf.append(name);
buf.append(": ");
if (body != null) {
buf.append(body);
}
return buf.toString();
}
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/BodyDescriptor.java 0000644 0000000 0000000 00000003072 11702050540 031234 0 ustar root root /****************************************************************
* 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;
/**
* A descriptor containing common MIME content body properties.
*/
public interface BodyDescriptor extends ContentDescriptor {
/**
* Returns the body descriptors boundary.
* @return Boundary string, if known, or null. The latter may be the
* case, in particular, if the body is no multipart entity.
*/
String getBoundary();
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/FieldBuilder.java 0000644 0000000 0000000 00000006112 11702050540 030630 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.util.ByteArrayBuffer;
/**
* Field builders are intended to construct {@link RawField} instances from multiple lines
* contained in {@link ByteArrayBuffer}s.
*
* Field builders are stateful and modal as they have to store intermediate results between
* method invocations and also rely on a particular sequence of method invocations
* (the mode of operation).
*
* Consumers are expected to interact with field builder in the following way:
*
*
*/
public interface FieldBuilder {
/**
* Resets the internal state of the builder making it ready to process new input.
*/
void reset();
/**
* Updates builder's internal state by adding a new line of text.
*/
void append(ByteArrayBuffer line) throws MimeException;
/**
* Builds an instance of {@link RawField} based on the internal state.
*/
RawField build() throws MimeException;
/**
* Returns combined content of all lines processed so far or null if they do not retain original raw content.null
* if the builder does not retain original raw content.
*/
ByteArrayBuffer getRaw();
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/EntityState.java 0000644 0000000 0000000 00000006003 11702050540 030552 0 ustar root root /****************************************************************
* 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;
/**
* Enumeration of states an entity is expected to go through
* in the process of the MIME stream parsing.
*/
public enum EntityState {
/**
* This token indicates, that the MIME stream is currently
* at the beginning of a message.
*/
T_START_MESSAGE,
/**
* This token indicates, that the MIME stream is currently
* at the end of a message.
*/
T_END_MESSAGE,
/**
* This token indicates, that a raw entity is currently being processed.
*/
T_RAW_ENTITY,
/**
* This token indicates, that a message parts headers are now
* being parsed.
*/
T_START_HEADER,
/**
* This token indicates, that a message parts field has now
* been parsed.
*/
T_FIELD,
/**
* This token indicates, that part headers have now been
* parsed.
*/
T_END_HEADER,
/**
* This token indicates, that a multipart body is being parsed.
*/
T_START_MULTIPART,
/**
* This token indicates, that a multipart body has been parsed.
*/
T_END_MULTIPART,
/**
* This token indicates, that a multiparts preamble is being
* parsed.
*/
T_PREAMBLE,
/**
* This token indicates, that a multiparts epilogue is being
* parsed.
*/
T_EPILOGUE,
/**
* This token indicates, that the MIME stream is currently
* at the beginning of a body part.
*/
T_START_BODYPART,
/**
* This token indicates, that the MIME stream is currently
* at the end of a body part.
*/
T_END_BODYPART,
/**
* This token indicates, that an atomic entity is being parsed.
*/
T_BODY,
/**
* This token indicates, that the MIME stream has been completely
* and successfully parsed, and no more data is available.
*/
T_END_OF_STREAM
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/RawBody.java 0000644 0000000 0000000 00000004535 11702050540 027654 0 ustar root root /****************************************************************
* 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.util.ArrayList;
import java.util.List;
/**
* This class represents a field's body consisting of a textual value and a number of optional
* name / value parameters separated with semicolon.
*
* value; param1 = value1; param2 = "value2";
*
*/
public final class RawBody {
private final String value;
private final List
*
*
* Copied from Apache HttpCore project
*/
public class ParserCursor {
private final int lowerBound;
private final int upperBound;
private int pos;
public ParserCursor(int lowerBound, int upperBound) {
super();
if (lowerBound < 0) {
throw new IndexOutOfBoundsException("Lower bound cannot be negative");
}
if (lowerBound > upperBound) {
throw new IndexOutOfBoundsException("Lower bound cannot be greater then upper bound");
}
this.lowerBound = lowerBound;
this.upperBound = upperBound;
this.pos = lowerBound;
}
public int getLowerBound() {
return this.lowerBound;
}
public int getUpperBound() {
return this.upperBound;
}
public int getPos() {
return this.pos;
}
public void updatePos(int pos) {
if (pos < this.lowerBound) {
throw new IndexOutOfBoundsException("pos: "+pos+" < lowerBound: "+this.lowerBound);
}
if (pos > this.upperBound) {
throw new IndexOutOfBoundsException("pos: "+pos+" > upperBound: "+this.upperBound);
}
this.pos = pos;
}
public boolean atEnd() {
return this.pos >= this.upperBound;
}
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append('[');
buffer.append(Integer.toString(this.lowerBound));
buffer.append('>');
buffer.append(Integer.toString(this.pos));
buffer.append('>');
buffer.append(Integer.toString(this.upperBound));
buffer.append(']');
return buffer.toString();
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/RawEntity.java 0000644 0000000 0000000 00000005652 11702050540 030234 0 ustar root root /****************************************************************
* 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.InputStream;
/**
* Raw MIME entity. Such entities will not be parsed into elements
* by the parser. They are meant to be consumed as a raw data stream
* by the caller.
*/
public class RawEntity implements EntityStateMachine {
private final InputStream stream;
private EntityState state;
RawEntity(InputStream stream) {
this.stream = stream;
this.state = EntityState.T_RAW_ENTITY;
}
public EntityState getState() {
return state;
}
/**
* This method has no effect.
*/
public void setRecursionMode(RecursionMode recursionMode) {
}
public EntityStateMachine advance() {
state = EntityState.T_END_OF_STREAM;
return null;
}
/**
* Returns raw data stream.
*/
public InputStream getContentStream() {
return stream;
}
/**
* This method has no effect and always returns null.
*/
public BodyDescriptor getBodyDescriptor() {
return null;
}
/**
* This method has no effect and always returns null.
*/
public RawField getField() {
return null;
}
/**
* This method has no effect and always returns null.
*/
public String getFieldName() {
return null;
}
/**
* This method has no effect and always returns null.
*/
public String getFieldValue() {
return null;
}
/**
* @see org.apache.james.mime4j.stream.EntityStateMachine#getDecodedContentStream()
*/
public InputStream getDecodedContentStream() throws IllegalStateException {
throw new IllegalStateException("Raw entity does not support stream decoding");
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/RawFieldParser.java 0000644 0000000 0000000 00000034565 11702050540 031165 0 ustar root root /****************************************************************
* 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.util.ArrayList;
import java.util.BitSet;
import java.util.List;
import org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.util.ByteSequence;
import org.apache.james.mime4j.util.CharsetUtil;
import org.apache.james.mime4j.util.ContentUtil;
/**
* Low level parser for header field elements. The parsing routines of this class are designed
* to produce near zero intermediate garbage and make no intermediate copies of input data.
*
* This class is immutable and thread safe.
*/
public class RawFieldParser {
public static BitSet INIT_BITSET(int ... b) {
BitSet bitset = new BitSet(b.length);
for (int i = 0; i < b.length; i++) {
bitset.set(b[i]);
}
return bitset;
}
static final BitSet COLON = INIT_BITSET(':');
static final BitSet EQUAL_OR_SEMICOLON = INIT_BITSET('=', ';');
static final BitSet SEMICOLON = INIT_BITSET(';');
public static final RawFieldParser DEFAULT = new RawFieldParser();
/**
* Parses the sequence of bytes into {@link RawField}.
*
* @throws MimeException if the input data does not contain a valid MIME field.
*/
public RawField parseField(final ByteSequence raw) throws MimeException {
if (raw == null) {
return null;
}
ParserCursor cursor = new ParserCursor(0, raw.length());
String name = parseToken(raw, cursor, COLON);
if (cursor.atEnd()) {
throw new MimeException("Invalid MIME field: no name/value separator found: " +
raw.toString());
}
return new RawField(raw, cursor.getPos(), name, null);
}
/**
* Parses the field body containing a value with parameters into {@link RawBody}.
*
* @param field unstructured (raw) field
*/
public RawBody parseRawBody(final RawField field) {
ByteSequence buf = field.getRaw();
int pos = field.getDelimiterIdx() + 1;
if (buf == null) {
String body = field.getBody();
if (body == null) {
return new RawBody("", null);
}
buf = ContentUtil.encode(body);
pos = 0;
}
ParserCursor cursor = new ParserCursor(pos, buf.length());
return parseRawBody(buf, cursor);
}
/**
* Parses the sequence of bytes containing a value with parameters into {@link RawBody}.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
*/
public RawBody parseRawBody(final ByteSequence buf, final ParserCursor cursor) {
String value = parseToken(buf, cursor, SEMICOLON);
if (cursor.atEnd()) {
return new RawBody(value, new ArrayListnull if the token
* is not delimited by any character.
*/
public String parseToken(final ByteSequence buf, final ParserCursor cursor, final BitSet delimiters) {
StringBuilder dst = new StringBuilder();
boolean whitespace = false;
while (!cursor.atEnd()) {
char current = (char) (buf.byteAt(cursor.getPos()) & 0xff);
if (delimiters != null && delimiters.get(current)) {
break;
} else if (CharsetUtil.isWhitespace(current)) {
skipWhiteSpace(buf, cursor);
whitespace = true;
} else if (current == '(') {
skipComment(buf, cursor);
} else {
if (dst.length() > 0 && whitespace) {
dst.append(' ');
}
copyContent(buf, cursor, delimiters, dst);
whitespace = false;
}
}
return dst.toString();
}
/**
* Extracts from the sequence of bytes a value which can be enclosed in quote marks and
* terminated with any of the given delimiters discarding semantically insignificant
* whitespace characters and comments.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
* @param delimiters set of delimiting characters. Can be null if the value
* is not delimited by any character.
*/
public String parseValue(final ByteSequence buf, final ParserCursor cursor, final BitSet delimiters) {
StringBuilder dst = new StringBuilder();
boolean whitespace = false;
while (!cursor.atEnd()) {
char current = (char) (buf.byteAt(cursor.getPos()) & 0xff);
if (delimiters != null && delimiters.get(current)) {
break;
} else if (CharsetUtil.isWhitespace(current)) {
skipWhiteSpace(buf, cursor);
whitespace = true;
} else if (current == '(') {
skipComment(buf, cursor);
} else if (current == '\"') {
if (dst.length() > 0 && whitespace) {
dst.append(' ');
}
copyQuotedContent(buf, cursor, dst);
whitespace = false;
} else {
if (dst.length() > 0 && whitespace) {
dst.append(' ');
}
copyContent(buf, cursor, delimiters, dst);
whitespace = false;
}
}
return dst.toString();
}
/**
* Skips semantically insignificant whitespace characters and moves the cursor to the closest
* non-whitespace character.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
*/
public void skipWhiteSpace(final ByteSequence buf, final ParserCursor cursor) {
int pos = cursor.getPos();
int indexFrom = cursor.getPos();
int indexTo = cursor.getUpperBound();
for (int i = indexFrom; i < indexTo; i++) {
char current = (char) (buf.byteAt(i) & 0xff);
if (!CharsetUtil.isWhitespace(current)) {
break;
} else {
pos++;
}
}
cursor.updatePos(pos);
}
/**
* Skips semantically insignificant content if the current position is positioned at the
* beginning of a comment and moves the cursor past the end of the comment.
* Nested comments and escaped characters are recognized and handled appropriately.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
*/
public void skipComment(final ByteSequence buf, final ParserCursor cursor) {
if (cursor.atEnd()) {
return;
}
int pos = cursor.getPos();
int indexFrom = cursor.getPos();
int indexTo = cursor.getUpperBound();
char current = (char) (buf.byteAt(pos) & 0xff);
if (current != '(') {
return;
}
pos++;
indexFrom++;
int level = 1;
boolean escaped = false;
for (int i = indexFrom; i < indexTo; i++, pos++) {
current = (char) (buf.byteAt(i) & 0xff);
if (escaped) {
escaped = false;
} else {
if (current == '\\') {
escaped = true;
} else if (current == '(') {
level++;
} else if (current == ')') {
level--;
}
}
if (level <= 0) {
pos++;
break;
}
}
cursor.updatePos(pos);
}
/**
* Skips semantically insignificant whitespace characters and comments and moves the cursor
* to the closest semantically significant non-whitespace character.
* Nested comments and escaped characters are recognized and handled appropriately.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
*/
public void skipAllWhiteSpace(final ByteSequence buf, final ParserCursor cursor) {
while (!cursor.atEnd()) {
char current = (char) (buf.byteAt(cursor.getPos()) & 0xff);
if (CharsetUtil.isWhitespace(current)) {
skipWhiteSpace(buf, cursor);
} else if (current == '(') {
skipComment(buf, cursor);
} else {
break;
}
}
}
/**
* Transfers content into the destination buffer until a whitespace character, a comment,
* or any of the given delimiters is encountered.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
* @param delimiters set of delimiting characters. Can be null if the value
* is delimited by a whitespace or a comment only.
* @param dst destination buffer
*/
public void copyContent(final ByteSequence buf, final ParserCursor cursor, final BitSet delimiters,
final StringBuilder dst) {
int pos = cursor.getPos();
int indexFrom = cursor.getPos();
int indexTo = cursor.getUpperBound();
for (int i = indexFrom; i < indexTo; i++) {
char current = (char) (buf.byteAt(i) & 0xff);
if ((delimiters != null && delimiters.get(current))
|| CharsetUtil.isWhitespace(current) || current == '(') {
break;
} else {
pos++;
dst.append(current);
}
}
cursor.updatePos(pos);
}
/**
* Transfers content enclosed with quote marks into the destination buffer.
*
* @param buf buffer with the sequence of bytes to be parsed
* @param cursor defines the bounds and current position of the buffer
* @param dst destination buffer
*/
public void copyQuotedContent(final ByteSequence buf, final ParserCursor cursor,
final StringBuilder dst) {
if (cursor.atEnd()) {
return;
}
int pos = cursor.getPos();
int indexFrom = cursor.getPos();
int indexTo = cursor.getUpperBound();
char current = (char) (buf.byteAt(pos) & 0xff);
if (current != '\"') {
return;
}
pos++;
indexFrom++;
boolean escaped = false;
for (int i = indexFrom; i < indexTo; i++, pos++) {
current = (char) (buf.byteAt(i) & 0xff);
if (escaped) {
if (current != '\"' && current != '\\') {
dst.append('\\');
}
dst.append(current);
escaped = false;
} else {
if (current == '\"') {
pos++;
break;
}
if (current == '\\') {
escaped = true;
} else if (current != '\r' && current != '\n') {
dst.append(current);
}
}
}
cursor.updatePos(pos);
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/MimeParseEventException.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/MimeParseEventExceptio0000644 0000000 0000000 00000003747 11702050540 031756 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.MimeException;
/**
* Indicates that strict parsing has been enabled
* and an optional invality has been found in the input.
* {@link #getEvent()} indicates the type of invalidity.
*/
public class MimeParseEventException extends MimeException {
private static final long serialVersionUID = 4632991604246852302L;
private final Event event;
/**
* Constructs an exception
* @param event MimeTokenStream.Event, not null
*/
public MimeParseEventException(final Event event) {
super(event.toString());
this.event = event;
}
/**
* Gets the causal parse event.
* @return MimeTokenStream.Event, not null
*/
public Event getEvent() {
return event;
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/DefaultFieldBuilder.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/DefaultFieldBuilder.ja0000644 0000000 0000000 00000006430 11702050540 031611 0 ustar root root /****************************************************************
* 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.util.BitSet;
import org.apache.james.mime4j.MimeException;
import org.apache.james.mime4j.io.MaxHeaderLengthLimitException;
import org.apache.james.mime4j.util.ByteArrayBuffer;
/**
* Default implementation of {@link FieldBuilder}.
*
*/
public class DefaultFieldBuilder implements FieldBuilder {
private static final BitSet FIELD_CHARS = new BitSet();
static {
for (int i = 0x21; i <= 0x39; i++) {
FIELD_CHARS.set(i);
}
for (int i = 0x3b; i <= 0x7e; i++) {
FIELD_CHARS.set(i);
}
}
private final ByteArrayBuffer buf;
private final int maxlen;
public DefaultFieldBuilder(int maxlen) {
this.buf = new ByteArrayBuffer(1024);
this.maxlen = maxlen;
}
public void reset() {
this.buf.clear();
}
public void append(final ByteArrayBuffer line) throws MaxHeaderLengthLimitException {
if (line == null) {
return;
}
int len = line.length();
if (this.maxlen > 0 && this.buf.length() + len >= this.maxlen) {
throw new MaxHeaderLengthLimitException("Maximum header length limit exceeded");
}
this.buf.append(line.buffer(), 0, line.length());
}
public RawField build() throws MimeException {
int len = this.buf.length();
if (len > 0) {
if (this.buf.byteAt(len - 1) == '\n') {
len --;
}
if (this.buf.byteAt(len - 1) == '\r') {
len --;
}
}
ByteArrayBuffer copy = new ByteArrayBuffer(this.buf.buffer(), len, false);
RawField field = RawFieldParser.DEFAULT.parseField(copy);
String name = field.getName();
for (int i = 0; i < name.length(); i++) {
char ch = name.charAt(i);
if (!FIELD_CHARS.get(ch)) {
throw new MimeException("MIME field name contains illegal characters: "
+ field.getName());
}
}
return field;
}
public ByteArrayBuffer getRaw() {
return this.buf;
}
}
apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/Field.java 0000644 0000000 0000000 00000004205 11702050540 027322 0 ustar root root /****************************************************************
* 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 org.apache.james.mime4j.util.ByteSequence;
/**
* This interface represents an abstract MIME field. A MIME field must have a non null
* name and a content body (unfolded but unparsed and possibly encoded). Optionally implementing
* classes may also retain the original (raw) representation in a form of {@link ByteSequence}.
*
* Specific implementations of this interface may also use a richer model to represent the field
* if its body can be parsed into a set of constituent elements.
*/
public interface Field {
/**
* Returns the name of the field.
*/
String getName();
/**
* Gets the unparsed and possibly encoded (see RFC 2047) field body string.
*
* @return the unparsed field body string.
*/
String getBody();
/**
* Gets original (raw) representation of the field, if available,
* null otherwise.
*/
ByteSequence getRaw();
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/BasicBodyDescriptor.java apache-mime4j-project-0.7.2/core/src/main/java/org/apache/james/mime4j/stream/BasicBodyDescriptor.ja0000644 0000000 0000000 00000005766 11702050540 031663 0 ustar root root /****************************************************************
* 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;
class BasicBodyDescriptor implements BodyDescriptor {
private final String mimeType;
private final String mediaType;
private final String subType;
private final String boundary;
private final String charset;
private final String transferEncoding;
private final long contentLength;
BasicBodyDescriptor(
final String mimeType,
final String mediaType,
final String subType,
final String boundary,
final String charset,
final String transferEncoding,
final long contentLength) {
super();
this.mimeType = mimeType;
this.mediaType = mediaType;
this.subType = subType;
this.boundary = boundary;
this.charset = charset;
this.transferEncoding = transferEncoding;
this.contentLength = contentLength;
}
public String getMimeType() {
return mimeType;
}
public String getMediaType() {
return mediaType;
}
public String getSubType() {
return subType;
}
public String getBoundary() {
return boundary;
}
public String getCharset() {
return charset;
}
public String getTransferEncoding() {
return transferEncoding;
}
public long getContentLength() {
return contentLength;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("[mimeType=");
sb.append(mimeType);
sb.append(", mediaType=");
sb.append(mediaType);
sb.append(", subType=");
sb.append(subType);
sb.append(", boundary=");
sb.append(boundary);
sb.append(", charset=");
sb.append(charset);
sb.append("]");
return sb.toString();
}
}
apache-mime4j-project-0.7.2/core/src/main/appended-resources/ 0000755 0000000 0000000 00000000000 11702050540 022513 5 ustar root root apache-mime4j-project-0.7.2/core/src/main/appended-resources/supplemental-models.xml 0000644 0000000 0000000 00000003771 11702050540 027237 0 ustar root root
Hey there!
Having a wonderful time...
take a look!
------------=_961872013-1436-1
Content-Type: image/jpeg; name="bluedot.jpg"
Content-Disposition: inline; filename="bluedot.jpg"
Content-Transfer-Encoding: base64
Content-Id: my-graphic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------------=_961872013-1436-1--
------------=_961872013-1436-0--
apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/multi-igor2.xml 0000644 0000000 0000000 00000025763 11702050534 027563 0 ustar root root Hey there!
Having a wonderful time...
take a look!
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/multi-2gifs-base64_decoded_1_1_3.bin apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/multi-2gifs-base64_decoded_1_0000644 0000000 0000000 00000000545 11702050534 032053 0 ustar root root GIF87a( ( ó ÌÝîÿ¾¾¾ˆˆˆnnnÌÝîÿÿÿççç , ( ( þÉI«½x–Ì;.2Œdižh
Jè¾p,ÇâZ{8Ö†mîS;Vèç ÞˆE[Y8Ÿã’ù¬Bk¼¡ÏÊD•ZN×z‘†-ãkÆŒI;S# ¸í†äYt:ÀïûûwByc|‡ˆ‰‰_ƒ]‰nUBV‘‡“c–G˜šœ“‚— ¡¢i¤Ÿ§©U±U«KOiN ¿²^X—N¸ ÆŸ¼V›¿ÀN´··¿ ˆOÙÎÈÑÆà¸ÎºŠÍÏWlàɾÎØåìÝÞÅÅíãŠãòÞ¸Öº¯fá)Í×±X*LhÍ#aǘ4œC!–ĉŽ$X¼8ðG ?‚Ì(²‚”’k”ØYÉrÄŠ0cÊœI³&ˆ ; apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/multi-simple.out 0000644 0000000 0000000 00000001224 11702050534 030023 0 ustar root root From: Nathaniel Borenstein
--90e6ba4fc6ea25d329048ec69d99--
apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/multi-frag_decoded_1_3_1.bin 0000644 0000000 0000000 00000000643 11702050534 031747 0 ustar root root GIF87a( ( ã € ÿ/OOnnnp€ R-¾¾¾çççõÞ³ÿ¥ ÿúÍ , ( ( þÉI«½x’Ì;&rŒdižh
Jè¾p,ÇâZ§xnÖa›À P˜ã±¨Â`Él68ãí¤d®XÀ3%õQ(íŠê"MYlrÌmõÎ|T
S•|2“ðyuy†%{m6^q†‚ƒ…‡$‰enGŽN †y”l–‹p€¥ˆ }—S ¯° “t©;«Œx ( ´•ª¢™»'½žµ|·Â#º¼¾ÀËoÃÏÇ¿¶%~ÍÄ&ƨɊÓ#ŽCA“
ÑÙ¸p$iW%êc
¡ãhY&ó b îIÃ&Ü µ @(„6Dàeé§à
ì>9yÒ/AdžY# ¾“˜†^‚“'A YBaŠŽ(U² ©Œ B”Ù1; Ìå;›8A>$™æàÍœÛý¤ÙÒhLùt¤0Ek¦ÔTY½*µ‹‡¯pq {bÅŒ³hÓª]ËD ; apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/ak-0696_decoded_1_1.txt 0000644 0000000 0000000 00000000041 11702050534 030512 0 ustar root root --
Juergen Specht - KULTURBOX
apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/frag_decoded_1_2_1_1.txt 0000644 0000000 0000000 00000000046 11702050534 031102 0 ustar root root just to add to your personal hell.
apache-mime4j-project-0.7.2/core/src/test/resources/mimetools-testmsgs/infinite.xml 0000644 0000000 0000000 00000012771 11702050534 027211 0 ustar root root