internetaddress.java

java Email you can use it to send email to others

		for (index++; index < length; index++) {
		    c = s.charAt(index);
		    switch (c) {
		    case '\\':
			index++; // skip both '\' and the escaped char
			break;
		    case '"':
			break outq; // out of for loop
		    default:
			break;
		    }
		}
		if (index >= length)
		    throw new AddressException("Missing '\"'", s, index);
		break;

	    case '[':	// a domain-literal, probably
		rfc822 = true;
	      outb:
		for (index++; index < length; index++) {
		    c = s.charAt(index);
		    switch (c) {
		    case '\\':
			index++; // skip both '\' and the escaped char
			break;
		    case ']':
			break outb; // out of for loop
		    default:
			break;
		    }
		}
		if (index >= length)
		    throw new AddressException("Missing ']'", s, index);
		break;

	    case ',':	// end of an address, probably
		if (start == -1) {
		    route_addr = false;
		    rfc822 = false;
		    start = end = -1;
		    break;	// nope, nothing there
		}
		if (in_group) {
		    route_addr = false;
		    break;
		}
		// got a token, add this to our InternetAddress vector
		if (end == -1)
		    end = index;
		String addr = s.substring(start, end).trim();
		if (rfc822 || strict || parseHdr) {
		    if (strict || !parseHdr)
			checkAddress(addr, route_addr, false);
		    ma = new InternetAddress();
		    ma.setAddress(addr);
		    if (start_personal >= 0) {
			ma.encodedPersonal = unquote(
			    s.substring(start_personal, end_personal).trim());
			start_personal = end_personal = -1;
		    }
		    v.addElement(ma);
		} else {
		    // maybe we passed over more than one space-separated addr
		    StringTokenizer st = new StringTokenizer(addr);
		    while (st.hasMoreTokens()) {
			String a = st.nextToken();
			checkAddress(a, false, false);
			ma = new InternetAddress();
			ma.setAddress(a);
			v.addElement(ma);
		    }
		}

		route_addr = false;
		rfc822 = false;
		start = end = -1;
		break;

	    case ':':
		rfc822 = true;
		if (in_group)
		    throw new AddressException("Nested group", s, index);
		in_group = true;
		if (start == -1)
		    start = index;
		break;

	    case ';':
		if (start == -1)
		    start = index;
		if (!in_group)
		    throw new AddressException(
			    "Illegal semicolon, not in group", s, index);
		in_group = false;
		if (start == -1)
		    start = index;
		ma = new InternetAddress();
		end = index + 1;
		ma.setAddress(s.substring(start, end).trim());
		v.addElement(ma);

		route_addr = false;
		start = end = -1;
		break;

	    // Ignore whitespace
	    case ' ':
	    case '\t':
	    case '\r':
	    case '\n':
		break;

	    default:
		if (start == -1)
		    start = index;
		break;
	     }
	}

	if (start >= 0) {
	    /*
	     * The last token, add this to our InternetAddress vector.
	     * Note that this block of code should be identical to the
	     * block above for "case ','".
	     */
	    if (end == -1)
		end = index;
	    String addr = s.substring(start, end).trim();
	    if (rfc822 || strict || parseHdr) {
		if (strict || !parseHdr)
		    checkAddress(addr, route_addr, false);
		ma = new InternetAddress();
		ma.setAddress(addr);
		if (start_personal >= 0) {
		    ma.encodedPersonal = unquote(
			    s.substring(start_personal, end_personal).trim());
		}
		v.addElement(ma);
	    } else {
		// maybe we passed over more than one space-separated addr
		StringTokenizer st = new StringTokenizer(addr);
		while (st.hasMoreTokens()) {
		    String a = st.nextToken();
		    checkAddress(a, false, false);
		    ma = new InternetAddress();
		    ma.setAddress(a);
		    v.addElement(ma);
		}
	    }
	}

	InternetAddress[] a = new InternetAddress[v.size()];
	v.copyInto(a);
	return a;
    }

    /**
     * Validate that this address conforms to the syntax rules of
     * RFC 822.  The current implementation checks many, but not
     * all, syntax rules.  Note that even though the syntax of
     * the address may be correct, there's no guarantee that a
     * mailbox of that name exists.
     *
     * @exception	AddressException if the address isn't valid.
     * @since		JavaMail 1.3
     */
    public void validate() throws AddressException {
	checkAddress(getAddress(), true, true);
    }

    private static final String specialsNoDotNoAt = "()<>,;:\\\"[]";
    private static final String specialsNoDot = specialsNoDotNoAt + "@";

    /**
     * Check that the address is a valid "mailbox" per RFC822.
     * (We also allow simple names.)
     *
     * XXX - much more to check
     * XXX - doesn't handle domain-literals properly (but no one uses them)
     */
    private static void checkAddress(String addr,
				boolean routeAddr, boolean validate)
				throws AddressException {
	int i, start = 0;
	if (addr.indexOf('"') >= 0)
	    return;			// quote in address, too hard to check
	if (routeAddr) {
	    /*
	     * Check for a legal "route-addr":
	     *		[@domain[,@domain ...]:]local@domain
	     */
	    for (start = 0; (i = indexOfAny(addr, ",:", start)) >= 0;
		    start = i+1) {
		if (addr.charAt(start) != '@')
		    throw new AddressException("Illegal route-addr", addr);
		if (addr.charAt(i) == ':') {
		    // end of route-addr
		    start = i + 1;
		    break;
		}
	    }
	}
	/*
	 * The rest should be "local@domain", but we allow simply "local"
	 * unless called from validate.
	 */
	String local;
	String domain;
	if ((i = addr.indexOf('@', start)) >= 0) {
	    if (i == start)
		throw new AddressException("Missing local name", addr);
	    if (i == addr.length() - 1)
		throw new AddressException("Missing domain", addr);
	    local = addr.substring(start, i);
	    domain = addr.substring(i + 1);
	} else {
	    /*
	     * Note that the MimeMessage class doesn't remember addresses
	     * as separate objects; it writes them out as headers and then
	     * parses the headers when the addresses are requested.
	     * In order to support the case where a "simple" address is used,
	     * but the address also has a personal name and thus looks like
	     * it should be a valid RFC822 address when parsed, we only check
	     * this if we're explicitly called from the validate method.
	     */
	    if (validate)
		throw new AddressException("Missing final '@domain'", addr);

	    /*
	     * No '@' so it's not *really* an RFC822 address, but still
	     * we allow some simple forms.
	     */
	    local = addr;
	    domain = null;
	}
	// there better not be any whitespace in it
	if (indexOfAny(addr, " \t\n\r") >= 0)
	    throw new AddressException("Illegal whitespace in address", addr);
	// local-part must follow RFC822, no specials except '.'
	if (indexOfAny(local, specialsNoDot) >= 0)
	    throw new AddressException("Illegal character in local name", addr);
	// check for illegal chars in the domain, but ignore domain literals
	if (domain != null && domain.indexOf('[') < 0) {
	    if (indexOfAny(domain, specialsNoDot) >= 0)
		throw new AddressException("Illegal character in domain", addr);
	}
    }

    /**
     * Is this a "simple" address?  Simple addresses don't contain quotes
     * or any RFC822 special characters other than '@' and '.'.
     */
    private boolean isSimple() {
	return address == null || indexOfAny(address, specialsNoDotNoAt) < 0;
    }

    /**
     * Indicates whether this address is an RFC 822 group address.
     * Note that a group address is different than the mailing
     * list addresses supported by most mail servers.  Group addresses
     * are rarely used; see RFC 822 for details.
     *
     * @return		true if this address represents a group
     * @since		JavaMail 1.3
     */
    public boolean isGroup() {
	// quick and dirty check
	return address != null &&
	    address.endsWith(";") && address.indexOf(':') > 0;
    }

    /**
     * Return the members of a group address.  A group may have zero,
     * one, or more members.  If this address is not a group, null
     * is returned.  The <code>strict</code> parameter controls whether
     * the group list is parsed using strict RFC 822 rules or not.
     * The parsing is done using the <code>parseHeader</code> method.
     *
     * @return		array of InternetAddress objects, or null
     * @exception	AddressException if the group list can't be parsed
     * @since		JavaMail 1.3
     */
    public InternetAddress[] getGroup(boolean strict) throws AddressException {
	Vector groups = null;
	String addr = getAddress();
	// groups are of the form "name:addr,addr,...;"
	if (!addr.endsWith(";"))
	    return null;
	int ix = addr.indexOf(':');
	if (ix < 0)
	    return null;
	// extract the list
	String list = addr.substring(ix + 1, addr.length() - 1);
	// parse it and return the individual addresses
	return InternetAddress.parseHeader(list, strict);
    }

    /**
     * Return the first index of any of the characters in "any" in "s",
     * or -1 if none are found.
     *
     * This should be a method on String.
     */
    private static int indexOfAny(String s, String any) {
	return indexOfAny(s, any, 0);
    }

    private static int indexOfAny(String s, String any, int start) {
	try {
	    int len = s.length();
	    for (int i = start; i < len; i++) {
		if (any.indexOf(s.charAt(i)) >= 0)
		    return i;
	    }
	    return -1;
	} catch (StringIndexOutOfBoundsException e) {
	    return -1;
	}
    }

    /*
    public static void main(String argv[]) throws Exception {
	for (int i = 0; i < argv.length; i++) {
	    InternetAddress[] a = InternetAddress.parse(argv[i]);
	    for (int j = 0; j < a.length; j++) {
		System.out.println("arg " + i + " address " + j + ": " + a[j]);
		System.out.println("\tAddress: " + a[j].getAddress() +
				    "\tPersonal: " + a[j].getPersonal());
	    }
	    if (a.length > 1) {
		System.out.println("address 0 hash code: " + a[0].hashCode());
		System.out.println("address 1 hash code: " + a[1].hashCode());
		if (a[0].hashCode() == a[1].hashCode())
		    System.out.println("success, hashcodes equal");
		else
		    System.out.println("fail, hashcodes not equal");
		if (a[0].equals(a[1]))
		    System.out.println("success, addresses equal");
		else
		    System.out.println("fail, addresses not equal");
		if (a[1].equals(a[0]))
		    System.out.println("success, addresses equal");
		else
		    System.out.println("fail, addresses not equal");
	    }
	}
    }
    */
}