trunk/src/main/org/apache/tools/ant/taskdefs/email/EmailTask.java - ant - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */
 package org.apache.tools.ant.taskdefs.email;

 import java.io.File;
 import java.util.Iterator;
 import java.util.StringTokenizer;
 import java.util.Vector;

 import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.Project;
 import org.apache.tools.ant.Task;
 import org.apache.tools.ant.types.EnumeratedAttribute;
 import org.apache.tools.ant.types.FileSet;
 import org.apache.tools.ant.types.Path;
 import org.apache.tools.ant.types.resources.FileResource;
 import org.apache.tools.ant.util.ClasspathUtils;

 /**
  * A task to send SMTP email. This is a refactoring of the SendMail and
  * MimeMail tasks such that both are within a single task.
  *
  * @since Ant 1.5
  * @ant.task name="mail" category="network"
  */
 public class EmailTask extends Task {
     private static final int SMTP_PORT = 25;

     /** Constant to show that the best available mailer should be used.  */
     public static final String AUTO = "auto";
     /** Constant to allow the Mime mailer to be requested  */
     public static final String MIME = "mime";
     /** Constant to allow the UU mailer to be requested  */
     public static final String UU = "uu";
     /** Constant to allow the plaintext mailer to be requested  */
     public static final String PLAIN = "plain";

     /**
      * Enumerates the encoding constants.
      */
     public static class Encoding extends EnumeratedAttribute {
         /**
          * finds the valid encoding values
          *
          * @return a list of valid entries
          */
         public String[] getValues() {
             return new String[] {AUTO, MIME, UU, PLAIN};
         }
     }

     private String encoding = AUTO;
     /** host running SMTP  */
     private String host = "localhost";
     private int port = SMTP_PORT;
     /** subject field  */
     private String subject = null;
     /** any text  */
     private Message message = null;
     /** failure flag */
     private boolean failOnError = true;
     private boolean includeFileNames = false;
     private String messageMimeType = null;
     /* special headers */
     /** sender  */
     private EmailAddress from = null;
     /** replyto */
     private Vector replyToList = new Vector();
     /** TO recipients  */
     private Vector toList = new Vector();
     /** CC (Carbon Copy) recipients  */
     private Vector ccList = new Vector();
     /** BCC (Blind Carbon Copy) recipients  */
     private Vector bccList = new Vector();

     /** generic headers */
     private Vector headers = new Vector();

     /** file list  */
     private Path attachments = null;
     /** Character set for MimeMailer*/
     private String charset = null;
     /** User for SMTP auth */
     private String user = null;
     /** Password for SMTP auth */
     private String password = null;
     /** indicate if the user wishes SSL-TLS */
     private boolean ssl = false;

     /**
      * Set the user for SMTP auth; this requires JavaMail.
      * @param user the String username.
      * @since Ant 1.6
      */
     public void setUser(String user) {
         this.user = user;
     }

     /**
      * Set the password for SMTP auth; this requires JavaMail.
      * @param password the String password.
      * @since Ant 1.6
      */
     public void setPassword(String password) {
         this.password = password;
     }

     /**
      * Set whether to send data over SSL.
      * @param ssl boolean; if true SSL will be used.
      * @since Ant 1.6
      */
     public void setSSL(boolean ssl) {
         this.ssl = ssl;
     }

     /**
      * Set the preferred encoding method.
      *
      * @param encoding The encoding (one of AUTO, MIME, UU, PLAIN).
      */
     public void setEncoding(Encoding encoding) {
         this.encoding = encoding.getValue();
     }

     /**
      * Set the mail server port.
      *
      * @param port The port to use.
      */
     public void setMailport(int port) {
         this.port = port;
     }

     /**
      * Set the host.
      *
      * @param host The host to connect to.
      */
     public void setMailhost(String host) {
         this.host = host;
     }

     /**
      * Set the subject line of the email.
      *
      * @param subject Subject of this email.
      */
     public void setSubject(String subject) {
         this.subject = subject;
     }

     /**
      * Shorthand method to set the message.
      *
      * @param message Message body of this email.
      */
     public void setMessage(String message) {
         if (this.message != null) {
             throw new BuildException("Only one message can be sent in an "
                  + "email");
         }
         this.message = new Message(message);
         this.message.setProject(getProject());
     }

     /**
      * Shorthand method to set the message from a file.
      *
      * @param file The file from which to take the message.
      */
     public void setMessageFile(File file) {
         if (this.message != null) {
             throw new BuildException("Only one message can be sent in an "
                  + "email");
         }
         this.message = new Message(file);
         this.message.setProject(getProject());
     }

     /**
      * Shorthand method to set type of the text message, text/plain by default
      * but text/html or text/xml is quite feasible.
      *
      * @param type The new MessageMimeType value.
      */
     public void setMessageMimeType(String type) {
         this.messageMimeType = type;
     }

     /**
      * Add a message element.
      *
      * @param message The message object.
      * @throws BuildException if a message has already been added.
      */
     public void addMessage(Message message) throws BuildException {
         if (this.message != null) {
             throw new BuildException(
                 "Only one message can be sent in an email");
         }
         this.message = message;
     }

     /**
      * Add a from address element.
      *
      * @param address The address to send from.
      */
     public void addFrom(EmailAddress address) {
         if (this.from != null) {
             throw new BuildException("Emails can only be from one address");
         }
         this.from = address;
     }

     /**
      * Shorthand to set the from address element.
      *
      * @param address The address to send mail from.
      */
     public void setFrom(String address) {
         if (this.from != null) {
             throw new BuildException("Emails can only be from one address");
         }
         this.from = new EmailAddress(address);
     }

     /**
      * Add a replyto address element.
      *
      * @param address The address to reply to.
      * @since Ant 1.6
      */
     public void addReplyTo(EmailAddress address) {
         this.replyToList.add(address);
     }

     /**
      * Shorthand to set the replyto address element.
      *
      * @param address The address to which replies should be directed.
      * @since Ant 1.6
      */
     public void setReplyTo(String address) {
         this.replyToList.add(new EmailAddress(address));
     }

     /**
      * Add a to address element.
      *
      * @param address An email address.
      */
     public void addTo(EmailAddress address) {
         toList.addElement(address);
     }

     /**
      * Shorthand to set the "to" address element.
      *
      * @param list Comma-separated list of addresses.
      */
     public void setToList(String list) {
         StringTokenizer tokens = new StringTokenizer(list, ",");

         while (tokens.hasMoreTokens()) {
             toList.addElement(new EmailAddress(tokens.nextToken()));
         }
     }

     /**
      * Add a "cc" address element.
      *
      * @param address The email address.
      */
     public void addCc(EmailAddress address) {
         ccList.addElement(address);
     }

     /**
      * Shorthand to set the "cc" address element.
      *
      * @param list Comma separated list of addresses.
      */
     public void setCcList(String list) {
         StringTokenizer tokens = new StringTokenizer(list, ",");

         while (tokens.hasMoreTokens()) {
             ccList.addElement(new EmailAddress(tokens.nextToken()));
         }
     }

     /**
      * Add a "bcc" address element.
      *
      * @param address The email address.
      */
     public void addBcc(EmailAddress address) {
         bccList.addElement(address);
     }

     /**
      * Shorthand to set the "bcc" address element.
      *
      * @param list comma separated list of addresses.
      */
     public void setBccList(String list) {
         StringTokenizer tokens = new StringTokenizer(list, ",");

         while (tokens.hasMoreTokens()) {
             bccList.addElement(new EmailAddress(tokens.nextToken()));
         }
     }

     /**
      * Set whether BuildExceptions should be passed back to the core.
      *
      * @param failOnError The new FailOnError value.
      */
     public void setFailOnError(boolean failOnError) {
         this.failOnError = failOnError;
     }

     /**
      * Set the list of files to be attached.
      *
      * @param filenames Comma-separated list of files.
      */
     public void setFiles(String filenames) {
         StringTokenizer t = new StringTokenizer(filenames, ", ");

         while (t.hasMoreTokens()) {
             createAttachments()
                 .add(new FileResource(getProject().resolveFile(t.nextToken())));
         }
     }

     /**
      * Add a set of files (nested fileset attribute).
      *
      * @param fs The fileset.
      */
     public void addFileset(FileSet fs) {
         createAttachments().add(fs);
     }

     /**
      * Creates a Path as container for attachments.  Supports any
      * filesystem resource-collections that way.
      * @return the path to be configured.
      * @since Ant 1.7
      */
     public Path createAttachments() {
         if (attachments == null) {
             attachments = new Path(getProject());
         }
         return attachments.createPath();
     }

     /**
      * Create a nested header element.
      * @return a Header instance.
      */
     public Header createHeader() {
         Header h = new Header();
         headers.add(h);
         return h;
     }

     /**
      * Set whether to include filenames.
      *
      * @param includeFileNames Whether to include filenames in the text of the
      *      message.
      */
     public void setIncludefilenames(boolean includeFileNames) {
         this.includeFileNames = includeFileNames;
     }

     /**
      * Get whether file names should be included.
      *
      * @return Identifies whether file names should be included.
      */
     public boolean getIncludeFileNames() {
         return includeFileNames;
     }

     /**
      * Send an email.
      */
     public void execute() {
         Message savedMessage = message;

         try {
             Mailer mailer = null;

             // prepare for the auto select mechanism
             boolean autoFound = false;
             // try MIME format
             if (encoding.equals(MIME)
                  || (encoding.equals(AUTO) && !autoFound)) {
                 try {
                     mailer = (Mailer) ClasspathUtils.newInstance(
                             "org.apache.tools.ant.taskdefs.email.MimeMailer",
                             EmailTask.class.getClassLoader(), Mailer.class);
                     autoFound = true;
                     log("Using MIME mail", Project.MSG_VERBOSE);
                 } catch (BuildException e) {
                     logBuildException("Failed to initialise MIME mail: ", e);
                     return;
                 }
             }
             // SMTP auth only allowed with MIME mail
             if (!autoFound && ((user != null) || (password != null))
                 && (encoding.equals(UU) || encoding.equals(PLAIN))) {
                 throw new BuildException("SMTP auth only possible with MIME mail");
             }
             // SSL only allowed with MIME mail
             if (!autoFound  && (ssl)
                 && (encoding.equals(UU) || encoding.equals(PLAIN))) {
                 throw new BuildException("SSL only possible with MIME mail");
             }
             // try UU format
             if (encoding.equals(UU)
                  || (encoding.equals(AUTO) && !autoFound)) {
                 try {
                     mailer = (Mailer) ClasspathUtils.newInstance(
                             "org.apache.tools.ant.taskdefs.email.UUMailer",
                             EmailTask.class.getClassLoader(), Mailer.class);
                     autoFound = true;
                     log("Using UU mail", Project.MSG_VERBOSE);
                 } catch (BuildException e) {
                     logBuildException("Failed to initialise UU mail: ", e);
                     return;
                 }
             }
             // try plain format
             if (encoding.equals(PLAIN)
                  || (encoding.equals(AUTO) && !autoFound)) {
                 mailer = new PlainMailer();
                 autoFound = true;
                 log("Using plain mail", Project.MSG_VERBOSE);
             }
             // a valid mailer must be present by now
             if (mailer == null) {
                 throw new BuildException("Failed to initialise encoding: "
                      + encoding);
             }
             // a valid message is required
             if (message == null) {
                 message = new Message();
                 message.setProject(getProject());
             }
             // an address to send from is required
             if (from == null || from.getAddress() == null) {
                 throw new BuildException("A from element is required");
             }
             // at least one address to send to/cc/bcc is required
             if (toList.isEmpty() && ccList.isEmpty() && bccList.isEmpty()) {
                 throw new BuildException("At least one of to, cc or bcc must "
                      + "be supplied");
             }
             // set the mimetype if not done already (and required)
             if (messageMimeType != null) {
                 if (message.isMimeTypeSpecified()) {
                     throw new BuildException("The mime type can only be "
                          + "specified in one location");
                 }
                 message.setMimeType(messageMimeType);
             }
             // set the character set if not done already (and required)
             if (charset != null) {
                 if (message.getCharset() != null) {
                     throw new BuildException("The charset can only be "
                          + "specified in one location");
                 }
                 message.setCharset(charset);
             }

             // identify which files should be attached
             Vector files = new Vector();
             if (attachments != null) {
                 Iterator iter = attachments.iterator();

                 while (iter.hasNext()) {
                     FileResource fr = (FileResource) iter.next();
                     files.addElement(fr.getFile());
                 }
             }
             // let the user know what's going to happen
             log("Sending email: " + subject, Project.MSG_INFO);
             log("From " + from, Project.MSG_VERBOSE);
             log("ReplyTo " + replyToList, Project.MSG_VERBOSE);
             log("To " + toList, Project.MSG_VERBOSE);
             log("Cc " + ccList, Project.MSG_VERBOSE);
             log("Bcc " + bccList, Project.MSG_VERBOSE);

             // pass the params to the mailer
             mailer.setHost(host);
             mailer.setPort(port);
             mailer.setUser(user);
             mailer.setPassword(password);
             mailer.setSSL(ssl);
             mailer.setMessage(message);
             mailer.setFrom(from);
             mailer.setReplyToList(replyToList);
             mailer.setToList(toList);
             mailer.setCcList(ccList);
             mailer.setBccList(bccList);
             mailer.setFiles(files);
             mailer.setSubject(subject);
             mailer.setTask(this);
             mailer.setIncludeFileNames(includeFileNames);
             mailer.setHeaders(headers);

             // send the email
             mailer.send();

             // let the user know what happened
             int count = files.size();

             log("Sent email with " + count + " attachment"
                  + (count == 1 ? "" : "s"), Project.MSG_INFO);
         } catch (BuildException e) {
             logBuildException("Failed to send email: ", e);
             if (failOnError) {
                 throw e;
             }
         } catch (Exception e) {
           log("Failed to send email: " + e.getMessage(), Project.MSG_WARN);
           if (failOnError) {
             throw new BuildException(e);
           }
         } finally {
             message = savedMessage;
         }
     }

     private void logBuildException(String reason, BuildException e) {
         Throwable t = e.getCause() == null ? e : e.getCause();
         log(reason + t.getMessage(), Project.MSG_WARN);
     }

     /**
      * Sets the character set of mail message.
      * Will be ignored if mimeType contains ....; Charset=... substring or
      * encoding is not a <code>mime</code>.
      * @param charset the character encoding to use.
      * @since Ant 1.6
      */
     public void setCharset(String charset) {
         this.charset = charset;
     }

     /**
      * Returns the character set of mail message.
      *
      * @return Charset of mail message.
      * @since Ant 1.6
      */
     public String getCharset() {
         return charset;
     }

 }
	/*
	* 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.tools.ant.taskdefs.email;

	import java.io.File;
	import java.util.Iterator;
	import java.util.StringTokenizer;
	import java.util.Vector;

	import org.apache.tools.ant.BuildException;
	import org.apache.tools.ant.Project;
	import org.apache.tools.ant.Task;
	import org.apache.tools.ant.types.EnumeratedAttribute;
	import org.apache.tools.ant.types.FileSet;
	import org.apache.tools.ant.types.Path;
	import org.apache.tools.ant.types.resources.FileResource;
	import org.apache.tools.ant.util.ClasspathUtils;

	/**
	* A task to send SMTP email. This is a refactoring of the SendMail and
	* MimeMail tasks such that both are within a single task.
	*
	* @since Ant 1.5
	* @ant.task name="mail" category="network"
	*/
	public class EmailTask extends Task {
	private static final int SMTP_PORT = 25;

	/** Constant to show that the best available mailer should be used. */
	public static final String AUTO = "auto";
	/** Constant to allow the Mime mailer to be requested */
	public static final String MIME = "mime";
	/** Constant to allow the UU mailer to be requested */
	public static final String UU = "uu";
	/** Constant to allow the plaintext mailer to be requested */
	public static final String PLAIN = "plain";

	/**
	* Enumerates the encoding constants.
	*/
	public static class Encoding extends EnumeratedAttribute {
	/**
	* finds the valid encoding values
	*
	* @return a list of valid entries
	*/
	public String[] getValues() {
	return new String[] {AUTO, MIME, UU, PLAIN};
	}
	}

	private String encoding = AUTO;
	/** host running SMTP */
	private String host = "localhost";
	private int port = SMTP_PORT;
	/** subject field */
	private String subject = null;
	/** any text */
	private Message message = null;
	/** failure flag */
	private boolean failOnError = true;
	private boolean includeFileNames = false;
	private String messageMimeType = null;
	/* special headers */
	/** sender */
	private EmailAddress from = null;
	/** replyto */
	private Vector replyToList = new Vector();
	/** TO recipients */
	private Vector toList = new Vector();
	/** CC (Carbon Copy) recipients */
	private Vector ccList = new Vector();
	/** BCC (Blind Carbon Copy) recipients */
	private Vector bccList = new Vector();

	/** generic headers */
	private Vector headers = new Vector();

	/** file list */
	private Path attachments = null;
	/** Character set for MimeMailer*/
	private String charset = null;
	/** User for SMTP auth */
	private String user = null;
	/** Password for SMTP auth */
	private String password = null;
	/** indicate if the user wishes SSL-TLS */
	private boolean ssl = false;

	/**
	* Set the user for SMTP auth; this requires JavaMail.
	* @param user the String username.
	* @since Ant 1.6
	*/
	public void setUser(String user) {
	this.user = user;
	}

	/**
	* Set the password for SMTP auth; this requires JavaMail.
	* @param password the String password.
	* @since Ant 1.6
	*/
	public void setPassword(String password) {
	this.password = password;
	}

	/**
	* Set whether to send data over SSL.
	* @param ssl boolean; if true SSL will be used.
	* @since Ant 1.6
	*/
	public void setSSL(boolean ssl) {
	this.ssl = ssl;
	}

	/**
	* Set the preferred encoding method.
	*
	* @param encoding The encoding (one of AUTO, MIME, UU, PLAIN).
	*/
	public void setEncoding(Encoding encoding) {
	this.encoding = encoding.getValue();
	}

	/**
	* Set the mail server port.
	*
	* @param port The port to use.
	*/
	public void setMailport(int port) {
	this.port = port;
	}

	/**
	* Set the host.
	*
	* @param host The host to connect to.
	*/
	public void setMailhost(String host) {
	this.host = host;
	}

	/**
	* Set the subject line of the email.
	*
	* @param subject Subject of this email.
	*/
	public void setSubject(String subject) {
	this.subject = subject;
	}

	/**
	* Shorthand method to set the message.
	*
	* @param message Message body of this email.
	*/
	public void setMessage(String message) {
	if (this.message != null) {
	throw new BuildException("Only one message can be sent in an "
	+ "email");
	}
	this.message = new Message(message);
	this.message.setProject(getProject());
	}

	/**
	* Shorthand method to set the message from a file.
	*
	* @param file The file from which to take the message.
	*/
	public void setMessageFile(File file) {
	if (this.message != null) {
	throw new BuildException("Only one message can be sent in an "
	+ "email");
	}
	this.message = new Message(file);
	this.message.setProject(getProject());
	}

	/**
	* Shorthand method to set type of the text message, text/plain by default
	* but text/html or text/xml is quite feasible.
	*
	* @param type The new MessageMimeType value.
	*/
	public void setMessageMimeType(String type) {
	this.messageMimeType = type;
	}

	/**
	* Add a message element.
	*
	* @param message The message object.
	* @throws BuildException if a message has already been added.
	*/
	public void addMessage(Message message) throws BuildException {
	if (this.message != null) {
	throw new BuildException(
	"Only one message can be sent in an email");
	}
	this.message = message;
	}

	/**
	* Add a from address element.
	*
	* @param address The address to send from.
	*/
	public void addFrom(EmailAddress address) {
	if (this.from != null) {
	throw new BuildException("Emails can only be from one address");
	}
	this.from = address;
	}

	/**
	* Shorthand to set the from address element.
	*
	* @param address The address to send mail from.
	*/
	public void setFrom(String address) {
	if (this.from != null) {
	throw new BuildException("Emails can only be from one address");
	}
	this.from = new EmailAddress(address);
	}

	/**
	* Add a replyto address element.
	*
	* @param address The address to reply to.
	* @since Ant 1.6
	*/
	public void addReplyTo(EmailAddress address) {
	this.replyToList.add(address);
	}

	/**
	* Shorthand to set the replyto address element.
	*
	* @param address The address to which replies should be directed.
	* @since Ant 1.6
	*/
	public void setReplyTo(String address) {
	this.replyToList.add(new EmailAddress(address));
	}

	/**
	* Add a to address element.
	*
	* @param address An email address.
	*/
	public void addTo(EmailAddress address) {
	toList.addElement(address);
	}

	/**
	* Shorthand to set the "to" address element.
	*
	* @param list Comma-separated list of addresses.
	*/
	public void setToList(String list) {
	StringTokenizer tokens = new StringTokenizer(list, ",");

	while (tokens.hasMoreTokens()) {
	toList.addElement(new EmailAddress(tokens.nextToken()));
	}
	}

	/**
	* Add a "cc" address element.
	*
	* @param address The email address.
	*/
	public void addCc(EmailAddress address) {
	ccList.addElement(address);
	}

	/**
	* Shorthand to set the "cc" address element.
	*
	* @param list Comma separated list of addresses.
	*/
	public void setCcList(String list) {
	StringTokenizer tokens = new StringTokenizer(list, ",");

	while (tokens.hasMoreTokens()) {
	ccList.addElement(new EmailAddress(tokens.nextToken()));
	}
	}

	/**
	* Add a "bcc" address element.
	*
	* @param address The email address.
	*/
	public void addBcc(EmailAddress address) {
	bccList.addElement(address);
	}

	/**
	* Shorthand to set the "bcc" address element.
	*
	* @param list comma separated list of addresses.
	*/
	public void setBccList(String list) {
	StringTokenizer tokens = new StringTokenizer(list, ",");

	while (tokens.hasMoreTokens()) {
	bccList.addElement(new EmailAddress(tokens.nextToken()));
	}
	}

	/**
	* Set whether BuildExceptions should be passed back to the core.
	*
	* @param failOnError The new FailOnError value.
	*/
	public void setFailOnError(boolean failOnError) {
	this.failOnError = failOnError;
	}

	/**
	* Set the list of files to be attached.
	*
	* @param filenames Comma-separated list of files.
	*/
	public void setFiles(String filenames) {
	StringTokenizer t = new StringTokenizer(filenames, ", ");

	while (t.hasMoreTokens()) {
	createAttachments()
	.add(new FileResource(getProject().resolveFile(t.nextToken())));
	}
	}

	/**
	* Add a set of files (nested fileset attribute).
	*
	* @param fs The fileset.
	*/
	public void addFileset(FileSet fs) {
	createAttachments().add(fs);
	}

	/**
	* Creates a Path as container for attachments. Supports any
	* filesystem resource-collections that way.
	* @return the path to be configured.
	* @since Ant 1.7
	*/
	public Path createAttachments() {
	if (attachments == null) {
	attachments = new Path(getProject());
	}
	return attachments.createPath();
	}

	/**
	* Create a nested header element.
	* @return a Header instance.
	*/
	public Header createHeader() {
	Header h = new Header();
	headers.add(h);
	return h;
	}

	/**
	* Set whether to include filenames.
	*
	* @param includeFileNames Whether to include filenames in the text of the
	* message.
	*/
	public void setIncludefilenames(boolean includeFileNames) {
	this.includeFileNames = includeFileNames;
	}

	/**
	* Get whether file names should be included.
	*
	* @return Identifies whether file names should be included.
	*/
	public boolean getIncludeFileNames() {
	return includeFileNames;
	}

	/**
	* Send an email.
	*/
	public void execute() {
	Message savedMessage = message;

	try {
	Mailer mailer = null;

	// prepare for the auto select mechanism
	boolean autoFound = false;
	// try MIME format
	if (encoding.equals(MIME)
	\|\| (encoding.equals(AUTO) && !autoFound)) {
	try {
	mailer = (Mailer) ClasspathUtils.newInstance(
	"org.apache.tools.ant.taskdefs.email.MimeMailer",
	EmailTask.class.getClassLoader(), Mailer.class);
	autoFound = true;
	log("Using MIME mail", Project.MSG_VERBOSE);
	} catch (BuildException e) {
	logBuildException("Failed to initialise MIME mail: ", e);
	return;
	}
	}
	// SMTP auth only allowed with MIME mail
	if (!autoFound && ((user != null) \|\| (password != null))
	&& (encoding.equals(UU) \|\| encoding.equals(PLAIN))) {
	throw new BuildException("SMTP auth only possible with MIME mail");
	}
	// SSL only allowed with MIME mail
	if (!autoFound && (ssl)
	&& (encoding.equals(UU) \|\| encoding.equals(PLAIN))) {
	throw new BuildException("SSL only possible with MIME mail");
	}
	// try UU format
	if (encoding.equals(UU)
	\|\| (encoding.equals(AUTO) && !autoFound)) {
	try {
	mailer = (Mailer) ClasspathUtils.newInstance(
	"org.apache.tools.ant.taskdefs.email.UUMailer",
	EmailTask.class.getClassLoader(), Mailer.class);
	autoFound = true;
	log("Using UU mail", Project.MSG_VERBOSE);
	} catch (BuildException e) {
	logBuildException("Failed to initialise UU mail: ", e);
	return;
	}
	}
	// try plain format
	if (encoding.equals(PLAIN)
	\|\| (encoding.equals(AUTO) && !autoFound)) {
	mailer = new PlainMailer();
	autoFound = true;
	log("Using plain mail", Project.MSG_VERBOSE);
	}
	// a valid mailer must be present by now
	if (mailer == null) {
	throw new BuildException("Failed to initialise encoding: "
	+ encoding);
	}
	// a valid message is required
	if (message == null) {
	message = new Message();
	message.setProject(getProject());
	}
	// an address to send from is required
	if (from == null \|\| from.getAddress() == null) {
	throw new BuildException("A from element is required");
	}
	// at least one address to send to/cc/bcc is required
	if (toList.isEmpty() && ccList.isEmpty() && bccList.isEmpty()) {
	throw new BuildException("At least one of to, cc or bcc must "
	+ "be supplied");
	}
	// set the mimetype if not done already (and required)
	if (messageMimeType != null) {
	if (message.isMimeTypeSpecified()) {
	throw new BuildException("The mime type can only be "
	+ "specified in one location");
	}
	message.setMimeType(messageMimeType);
	}
	// set the character set if not done already (and required)
	if (charset != null) {
	if (message.getCharset() != null) {
	throw new BuildException("The charset can only be "
	+ "specified in one location");
	}
	message.setCharset(charset);
	}

	// identify which files should be attached
	Vector files = new Vector();
	if (attachments != null) {
	Iterator iter = attachments.iterator();

	while (iter.hasNext()) {
	FileResource fr = (FileResource) iter.next();
	files.addElement(fr.getFile());
	}
	}
	// let the user know what's going to happen
	log("Sending email: " + subject, Project.MSG_INFO);
	log("From " + from, Project.MSG_VERBOSE);
	log("ReplyTo " + replyToList, Project.MSG_VERBOSE);
	log("To " + toList, Project.MSG_VERBOSE);
	log("Cc " + ccList, Project.MSG_VERBOSE);
	log("Bcc " + bccList, Project.MSG_VERBOSE);

	// pass the params to the mailer
	mailer.setHost(host);
	mailer.setPort(port);
	mailer.setUser(user);
	mailer.setPassword(password);
	mailer.setSSL(ssl);
	mailer.setMessage(message);
	mailer.setFrom(from);
	mailer.setReplyToList(replyToList);
	mailer.setToList(toList);
	mailer.setCcList(ccList);
	mailer.setBccList(bccList);
	mailer.setFiles(files);
	mailer.setSubject(subject);
	mailer.setTask(this);
	mailer.setIncludeFileNames(includeFileNames);
	mailer.setHeaders(headers);

	// send the email
	mailer.send();

	// let the user know what happened
	int count = files.size();

	log("Sent email with " + count + " attachment"
	+ (count == 1 ? "" : "s"), Project.MSG_INFO);
	} catch (BuildException e) {
	logBuildException("Failed to send email: ", e);
	if (failOnError) {
	throw e;
	}
	} catch (Exception e) {
	log("Failed to send email: " + e.getMessage(), Project.MSG_WARN);
	if (failOnError) {
	throw new BuildException(e);
	}
	} finally {
	message = savedMessage;
	}
	}

	private void logBuildException(String reason, BuildException e) {
	Throwable t = e.getCause() == null ? e : e.getCause();
	log(reason + t.getMessage(), Project.MSG_WARN);
	}

	/**
	* Sets the character set of mail message.
	* Will be ignored if mimeType contains ....; Charset=... substring or
	* encoding is not a <code>mime</code>.
	* @param charset the character encoding to use.
	* @since Ant 1.6
	*/
	public void setCharset(String charset) {
	this.charset = charset;
	}

	/**
	* Returns the character set of mail message.
	*
	* @return Charset of mail message.
	* @since Ant 1.6
	*/
	public String getCharset() {
	return charset;
	}

	}