/*********************************************************************** * Copyright (c) 2000-2004 The Apache Software Foundation.             * * All rights reserved.                                                * * ------------------------------------------------------------------- * * Licensed 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.hwmhere.email.mailet;import java.util.Locale;/** * A representation of an email address. * <p> * This class encapsulates functionalities to access to different parts of an * email address without dealing with its parsing. * </p> *  * <p> * A MailAddress is an address specified in the MAIL FROM and RCPT TO commands * in SMTP sessions. These are either passed by an external server to the * mailet-compliant SMTP server, or they are created programmatically by the * mailet-compliant server to send to another (external) SMTP server. Mailets * and matchers use the MailAddress for the purpose of evaluating the sender and * recipient(s) of a message. * </p> *  * <p> * MailAddress parses an email address as defined in RFC 821 (SMTP) p. 30 and 31 * where addresses are defined in BNF convention. As the mailet API does not * support the aged "SMTP-relayed mail" addressing protocol, this leaves all * addresses to be a <mailbox>, as per the spec. The MailAddress's "user" is the * <local-part> of the <mailbox> and "host" is the <domain> of the mailbox. * </p> *  * <p> * This class is a good way to validate email addresses as there are some valid * addresses which would fail with a simpler approach to parsing address. It * also removes parsing burden from mailets and matchers that might not realize * the flexibility of an SMTP address. For instance, "serge@home"@lokitech.com * is a valid SMTP address (the quoted text serge@home is the user and * lokitech.com is the host). This means all current parsing to date is * incorrect as we just find the first @ and use that to separate user from * host. * </p> *  * <p> * This parses an address as per the BNF specification for <mailbox> from RFC * 821 on page 30 and 31, section 4.1.2. COMMAND SYNTAX. * http://www.freesoft.org/CIE/RFC/821/15.htm * </p> *  * @version 1.0 */public class MailAddress implements java.io.Serializable {	// We hardcode the serialVersionUID so that from James 1.2 on,	// MailAddress will be deserializable (so your mail doesn't get lost)	public static final long serialVersionUID = 2779163542539434916L;	private final static char[] SPECIAL = { '<', '>', '(', ')', '[', ']', '\\',			'.', ',', ';', ':', '@', '\"' };	private String user = null;	private String host = null;	// Used for parsing	private int pos = 0;	/**	 * <p>	 * Construct a MailAddress parsing the provided <code>String</code>	 * object.	 * </p>	 * 	 * <p>	 * The <code>personal</code> variable is left empty.	 * </p>	 * 	 * @param address	 *            the email address compliant to the RFC822 format	 * @throws ParseException	 *             if the parse failed	 */	public MailAddress(String address) throws Exception {		address = address.trim();		int i = address.indexOf('@');		if (1 == i) {		}		user = address.substring(0, i);		host = address.substring(i + 1);		// StringBuffer userSB = new StringBuffer();		// StringBuffer hostSB = new StringBuffer();		// //Begin parsing		// //<mailbox> ::= <local-part> "@" <domain>		//		// try {		// //parse local-part		// //<local-part> ::= <dot-string> | <quoted-string>		// if (address.charAt(pos) == '\"') {		// userSB.append(parseQuotedLocalPart(address));		// } else {		// userSB.append(parseUnquotedLocalPart(address));		// }		// if (userSB.toString().length() == 0) {		// throw new Exception("No local-part (user account) found at position "		// + (pos + 1));		// }		//		// //find @		// if (pos >= address.length() || address.charAt(pos) != '@') {		// throw new Exception("Did not find @ between local-part and domain at		// position " + (pos + 1));		// }		// pos++;		//		// //parse domain		// //<domain> ::= <element> | <element> "." <domain>		// //<element> ::= <name> | "#" <number> | "[" <dotnum> "]"		// while (true) {		// if (address.charAt(pos) == '#') {		// hostSB.append(parseNumber(address));		// } else if (address.charAt(pos) == '[') {		// hostSB.append(parseDotNum(address));		// } else {		// hostSB.append(parseDomainName(address));		// }		// if (pos >= address.length()) {		// break;		// }		// if (address.charAt(pos) == '.') {		// hostSB.append('.');		// pos++;		// continue;		// }		// break;		// }		//		// if (hostSB.toString().length() == 0) {		// throw new Exception("No domain found at position " + (pos + 1));		// }		// } catch (IndexOutOfBoundsException ioobe) {		// throw new Exception("Out of data at position " + (pos + 1));		// }		//		// user = userSB.toString();		// host = hostSB.toString();	}	/**	 * Construct a MailAddress with the provided personal name and email	 * address.	 * 	 * @param user	 *            the username or account name on the mail server	 * @param host	 *            the server that should accept messages for this user	 * @throws Exception	 *             if the parse failed	 */	public MailAddress(String newUser, String newHost) throws Exception {		/* NEEDS TO BE REWORKED TO VALIDATE EACH CHAR */		user = newUser;		host = newHost;	}	/**	 * Constructs a MailAddress from a JavaMail InternetAddress, using only the	 * email address portion, discarding the personal name.	 */	// public MailAddress(InternetAddress address) throws Exception {	// this(address.getAddress());	// }	/**	 * Return the host part.	 * 	 * @return a <code>String</code> object representing the host part of this	 *         email address. If the host is of the dotNum form (e.g.	 *         [yyy.yyy.yyy.yyy]) then strip the braces first.	 */	public String getHost() {		if (!(host.startsWith("[") && host.endsWith("]"))) {			return host;		} else {			return host.substring(1, host.length() - 1);		}	}	/**	 * Return the user part.	 * 	 * @return a <code>String</code> object representing the user part of this	 *         email address.	 * @throws AddressException	 *             if the parse failed	 */	public String getUser() {		return user;	}	public String toString() {		StringBuffer addressBuffer = new StringBuffer(128).append(user).append(				"@").append(host);		return addressBuffer.toString();	}	// public InternetAddress toInternetAddress() {	// try {	// return new InternetAddress(toString());	// } catch (javax.mail.internet.AddressException ae) {	// //impossible really	// return null;	// }	// }	public boolean equals(Object obj) {		if (obj == null) {			return false;		} else if (obj instanceof String) {			String theString = (String) obj;			return toString().equalsIgnoreCase(theString);		} else if (obj instanceof MailAddress) {			MailAddress addr = (MailAddress) obj;			return getUser().equalsIgnoreCase(addr.getUser())					&& getHost().equalsIgnoreCase(addr.getHost());		}		return false;	}	/**	 * Return a hashCode for this object which should be identical for addresses	 * which are equivalent. This is implemented by obtaining the default	 * hashcode of the String representation of the MailAddress. Without this	 * explicit definition, the default hashCode will create different hashcodes	 * for separate object instances.	 *