/****************************************************************
* 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.jsieve.util.check;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
import java.util.ListIterator;
import javax.mail.Header;
import javax.mail.Message;
import javax.mail.MessagingException;
import org.apache.jsieve.exception.SieveException;
import org.apache.jsieve.mail.Action;
import org.apache.jsieve.mail.MailAdapter;
import org.apache.jsieve.mail.MailUtils;
import org.apache.jsieve.mail.SieveMailException;
import org.apache.jsieve.parser.address.SieveAddressBuilder;
/**
* Checks script execution for an email. The wrapped email is set by called
* {@link #setMail}. Actions are recorded on {@link #executedActions} and can
* be retrieved by {@link #getExecutedActions()}.
*/
public class ScriptCheckMailAdapter implements MailAdapter {
private final List actions;
private final List executedActions;
private Message mail = null;
public ScriptCheckMailAdapter() {
actions = new ArrayList();
executedActions = new ArrayList();
}
/**
* Gets the wrapped email.
*
* @return <code>Message</code>, possibly null
*/
public Message getMail() {
return mail;
}
/**
* Sets the wrapped email and {@link #reset}s the adapter ready for another
* execution.
*
* @param mail
* <code>Message</code>, possibly null
*/
public void setMail(Message mail) {
this.mail = mail;
reset();
}
/**
* Method addAction adds an Action to the List of Actions to be performed by
* the receiver.
*
* @param action
*/
public void addAction(final Action action) {
actions.add(action);
}
/**
* Method executeActions. Applies the Actions accumulated by the receiver.
*/
public void executeActions() throws SieveException {
executedActions.clear();
executedActions.addAll(actions);
}
/**
* Gets the actions accumulated when {@link #executedActions} was last
* called.
*
* @return <code>List</code> of {@link Action}s, not null. This list is a
* modifiable copy
*/
public List getExecutedActions() {
final ArrayList result = new ArrayList(executedActions);
return result;
}
/**
* Method getActions answers the List of Actions accumulated by the
* receiver. Implementations may elect to supply an unmodifiable collection.
*
* @return <code>List</code> of {@link Action}'s, not null, possibly
* unmodifiable
*/
public List getActions() {
final List result = Collections.unmodifiableList(actions);
return result;
}
/**
* Method getActionIteraror answers an Iterator over the List of Actions
* accumulated by the receiver. Implementations may elect to supply an
* unmodifiable iterator.
*
* @return <code>ListIterator</code>, not null, possibly unmodifiable
*/
public ListIterator getActionsIterator() {
final List unmodifiableActions = getActions();
final ListIterator result = unmodifiableActions.listIterator();
return result;
}
/**
* Resets executed and accumlated actions. An instance may be safely reused
* to check a script once this method has been called.
*/
public void reset() {
executedActions.clear();
actions.clear();
}
/**
* Method getHeader answers a List of all of the headers in the receiver
* whose name is equal to the passed name. If no headers are found an empty
* List is returned.
*
* @param name
* @return <code>List</code> not null, possibly empty
* @throws SieveMailException
*/
public List getHeader(String name) throws SieveMailException {
List result = Collections.EMPTY_LIST;
if (mail != null) {
try {
String[] values = mail.getHeader(name);
if (values != null) {
result = Arrays.asList(values);
}
} catch (MessagingException e) {
throw new SieveMailException(e);
}
}
return result;
}
/**
* Method getHeaderNames answers a List of all of the headers in the
* receiver. No duplicates are allowed.
*
* @return <code>List</code>, not null possible empty, possible
* unmodifiable
* @throws SieveMailException
*/
public List getHeaderNames() throws SieveMailException {
List results = Collections.EMPTY_LIST;
if (mail != null) {
try {
results = new ArrayList();
for (final Enumeration en = mail.getAllHeaders(); en
.hasMoreElements();) {
final Header header = (Header) en.nextElement();
final String name = header.getName();
if (!results.contains(name)) {
results.add(name);
}
}
} catch (MessagingException e) {
throw new SieveMailException(e);
}
}
return results;
}
/**
* <p>
* Method getMatchingHeader answers a List of all of the headers in the
* receiver with the passed name. If no headers are found an empty List is
* returned.
* </p>
*
* <p>
* This method differs from getHeader(String) in that it ignores case and
* the whitespace prefixes and suffixes of a header name when performing the
* match, as required by RFC 3028. Thus "From", "from ", " From" and " from "
* are considered equal.
* </p>
*
* @param name
* @return <code>List</code>, not null possibly empty
* @throws SieveMailException
*/
public List getMatchingHeader(String name) throws SieveMailException {
List result = Collections.EMPTY_LIST;
if (mail != null) {
result = MailUtils.getMatchingHeader(this, name);
}
return result;
}
/**
* Method getSize answers the receiver's message size in octets.
*
* @return int
* @throws SieveMailException
*/
public int getSize() throws SieveMailException {
int result = 0;
if (mail != null) {
try {
result = mail.getSize();
} catch (MessagingException e) {
throw new SieveMailException(e);
}
}
return result;
}
/**
* Method getContentType returns string/mime representation of the message
* type.
*
* @return String
* @throws SieveMailException
*/
public String getContentType() throws SieveMailException {
String result = null;
if (mail != null) {
try {
result = mail.getContentType();
} catch (MessagingException e) {
throw new SieveMailException(e);
}
}
return result;
}
/**
* Method getContent returns object containing the message content.
*
* @return Object
* @throws SieveMailException
*/
public Object getContent() throws SieveMailException {
Object result = null;
if (mail != null) {
try {
result = mail.getContent();
} catch (MessagingException e) {
throw new SieveMailException(e);
} catch (IOException e) {
throw new SieveMailException(e);
}
}
return result;
}
public Address[] parseAddresses(String headerName)
throws SieveMailException {
return parseAddresses(headerName, mail);
}
/**
* Parses the value from the given message into addresses.
*
* @param headerName
* header name, to be matched case insensitively
* @param message
* <code>Message</code>, not null
* @return <code>Address</code> array, not null possibly empty
* @throws SieveMailException
*/
public Address[] parseAddresses(final String headerName,
final Message message) throws SieveMailException {
try {
final SieveAddressBuilder builder = new SieveAddressBuilder();
for (Enumeration en = message.getAllHeaders(); en.hasMoreElements();) {
final Header header = (Header) en.nextElement();
final String name = header.getName();
if (name.trim().equalsIgnoreCase(headerName)) {
builder.addAddresses(header.getValue());
}
}
final Address[] results = builder.getAddresses();
return results;
} catch (MessagingException ex) {
throw new SieveMailException(ex);
} catch (org.apache.jsieve.parser.generated.address.ParseException ex) {
throw new SieveMailException(ex);
}
}
}