mailaddress.java

基于UDP的可靠邮件系统

/***********************************************************************
 * 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.
	 *