    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.validator;
    018
    019import java.util.regex.Matcher;
    020import java.util.regex.Pattern;
    021
    022import org.apache.commons.validator.routines.InetAddressValidator;
    023
    024/**
    025 * <p>Perform email validations.</p>
    026 * <p>
    027 * This class is a Singleton; you can retrieve the instance via the getInstance() method.
    028 * </p>
    029 * <p>
    030 * Based on a script by <a href="mailto:stamhankar@hotmail.com">Sandeep V. Tamhankar</a>
    031 * http://javascript.internet.com
    032 * </p>
    033 * <p>
    034 * This implementation is not guaranteed to catch all possible errors in an email address.
    035 * For example, an address like nobody@noplace.somedog will pass validator, even though there
    036 * is no TLD "somedog"
    037 * </p>.
    038 *
    039 * @since 1.1
    040 * @deprecated Use the new EmailValidator in the routines package. This class
    041 * will be removed in a future release.
    042 */
    043@Deprecated
    044public class EmailValidator {
    045
    046    private static final String SPECIAL_CHARS = "\\p{Cntrl}\\(\\)<>@,;:'\\\\\\\"\\.\\[\\]";
    047    private static final String VALID_CHARS = "[^\\s" + SPECIAL_CHARS + "]";
    048    private static final String QUOTED_USER = "(\"[^\"]*\")";
    049    private static final String ATOM = VALID_CHARS + '+';
    050    private static final String WORD = "((" + VALID_CHARS + "|')+|" + QUOTED_USER + ")";
    051
    052// NOT USED   private static final Pattern LEGAL_ASCII_PATTERN = Pattern.compile("^\\p{ASCII}+$");
    053// NOT USED   private static final Pattern EMAIL_PATTERN = Pattern.compile("^(.+)@(.+)$");
    054    private static final Pattern IP_DOMAIN_PATTERN = Pattern.compile("^\\[(.*)\\]$");
    055    private static final Pattern TLD_PATTERN = Pattern.compile("^([a-zA-Z]+)$");
    056
    057    private static final Pattern USER_PATTERN = Pattern.compile("^\\s*" + WORD + "(\\." + WORD + ")*$");
    058    private static final Pattern DOMAIN_PATTERN = Pattern.compile("^" + ATOM + "(\\." + ATOM + ")*\\s*$");
    059    private static final Pattern ATOM_PATTERN = Pattern.compile("(" + ATOM + ")");
    060
    061    /**
    062     * Singleton instance of this class.
    063     */
    064    private static final EmailValidator EMAIL_VALIDATOR = new EmailValidator();
    065
    066    /**
    067     * Returns the Singleton instance of this validator.
    068     * @return singleton instance of this validator.
    069     */
    070    public static EmailValidator getInstance() {
    071        return EMAIL_VALIDATOR;
    072    }
    073
    074    /**
    075     * Protected constructor for subclasses to use.
    076     */
    077    protected EmailValidator() {
    078    }
    079
    080    /**
    081     * <p>Checks if a field has a valid e-mail address.</p>
    082     *
    083     * @param email The value validation is being performed on.  A <code>null</code>
    084     * value is considered invalid.
    085     * @return true if the email address is valid.
    086     */
    087    public boolean isValid(final String email) {
    088        return org.apache.commons.validator.routines.EmailValidator.getInstance().isValid(email);
    089    }
    090
    091    /**
    092     * Returns true if the domain component of an email address is valid.
    093     * @param domain being validated.
    094     * @return true if the email address's domain is valid.
    095     */
    096    protected boolean isValidDomain(final String domain) {
    097        boolean symbolic = false;
    098
    099        // see if domain is an IP address in brackets
    100        final Matcher ipDomainMatcher = IP_DOMAIN_PATTERN.matcher(domain);
    101
    102        if (ipDomainMatcher.matches()) {
    103            final InetAddressValidator inetAddressValidator =
    104                    InetAddressValidator.getInstance();
    105            if (inetAddressValidator.isValid(ipDomainMatcher.group(1))) {
    106                return true;
    107            }
    108        } else {
    109            // Domain is symbolic name
    110            symbolic = DOMAIN_PATTERN.matcher(domain).matches();
    111        }
    112
    113        if (!symbolic) {
    114            return false;
    115        }
    116        if (!isValidSymbolicDomain(domain)) {
    117            return false;
    118        }
    119
    120        return true;
    121    }
    122
    123    /**
    124     * Validates an IP address. Returns true if valid.
    125     * @param ipAddress IP address
    126     * @return true if the ip address is valid.
    127     */
    128    protected boolean isValidIpAddress(final String ipAddress) {
    129        final Matcher ipAddressMatcher = IP_DOMAIN_PATTERN.matcher(ipAddress);
    130        for (int i = 1; i <= 4; i++) { // CHECKSTYLE IGNORE MagicNumber
    131            final String ipSegment = ipAddressMatcher.group(i);
    132            if (ipSegment == null || ipSegment.isEmpty()) {
    133                return false;
    134            }
    135
    136            int iIpSegment = 0;
    137
    138            try {
    139                iIpSegment = Integer.parseInt(ipSegment);
    140            } catch (final NumberFormatException e) {
    141                return false;
    142            }
    143
    144            if (iIpSegment > 255) { // CHECKSTYLE IGNORE MagicNumber
    145                return false;
    146            }
    147
    148        }
    149        return true;
    150    }
    151
    152    /**
    153     * Validates a symbolic domain name.  Returns true if it's valid.
    154     * @param domain symbolic domain name
    155     * @return true if the symbolic domain name is valid.
    156     */
    157    protected boolean isValidSymbolicDomain(String domain) {
    158        final String[] domainSegment = new String[10]; // CHECKSTYLE IGNORE MagicNumber
    159        boolean match = true;
    160        int i = 0;
    161        final Matcher atomMatcher = ATOM_PATTERN.matcher(domain);
    162        while (match) {
    163            match = atomMatcher.matches();
    164            if (match) {
    165                domainSegment[i] = atomMatcher.group(1);
    166                final int l = domainSegment[i].length() + 1;
    167                domain =
    168                        l >= domain.length()
    169                        ? ""
    170                        : domain.substring(l);
    171
    172                i++;
    173            }
    174        }
    175
    176        final int len = i;
    177
    178        // Make sure there's a host name preceding the domain.
    179        if (len < 2) {
    180            return false;
    181        }
    182
    183        final String tld = domainSegment[len - 1];
    184        if (tld.length() <= 1) {
    185            return false;
    186        }
    187        if (! TLD_PATTERN.matcher(tld).matches()) {
    188            return false;
    189        }
    190
    191        return true;
    192    }
    193
    194    /**
    195     * Returns true if the user component of an email address is valid.
    196     * @param user being validated
    197     * @return true if the user name is valid.
    198     */
    199    protected boolean isValidUser(final String user) {
    200        return USER_PATTERN.matcher(user).matches();
    201    }
    202
    203    /**
    204     * Recursively remove comments, and replace with a single space. The simpler regexps in the Email Addressing FAQ are imperfect - they will miss escaped
    205     * chars in atoms, for example. Derived From Mail::RFC822::Address
    206     *
    207     * @param emailStr The email address
    208     * @return address with comments removed.
    209     */
    210    protected String stripComments(final String emailStr) {
    211        String result = emailStr;
    212        final String commentPat = "^((?:[^\"\\\\]|\\\\.)*(?:\"(?:[^\"\\\\]|\\\\.)*\"(?:[^\"\\\\]|\111111\\\\.)*)*)\\((?:[^()\\\\]|\\\\.)*\\)/";
    213        final Pattern commentMatcher = Pattern.compile(commentPat);
    214
    215        while (commentMatcher.matcher(result).matches()) {
    216            result = result.replaceFirst(commentPat, "\1 ");
    217        }
    218        return result;
    219    }
    220}