    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 *      https://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 * https://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}
    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 || !isValidSymbolicDomain(domain)) {
    114            return false;
    115        }
    116
    117        return true;
    118    }
    119
    120    /**
    121     * Validates an IP address. Returns true if valid.
    122     * @param ipAddress IP address
    123     * @return true if the ip address is valid.
    124     */
    125    protected boolean isValidIpAddress(final String ipAddress) {
    126        final Matcher ipAddressMatcher = IP_DOMAIN_PATTERN.matcher(ipAddress);
    127        for (int i = 1; i <= 4; i++) { // CHECKSTYLE IGNORE MagicNumber
    128            final String ipSegment = ipAddressMatcher.group(i);
    129            if (ipSegment == null || ipSegment.isEmpty()) {
    130                return false;
    131            }
    132
    133            int iIpSegment = 0;
    134
    135            try {
    136                iIpSegment = Integer.parseInt(ipSegment);
    137            } catch (final NumberFormatException e) {
    138                return false;
    139            }
    140
    141            if (iIpSegment > 255) { // CHECKSTYLE IGNORE MagicNumber
    142                return false;
    143            }
    144
    145        }
    146        return true;
    147    }
    148
    149    /**
    150     * Validates a symbolic domain name.  Returns true if it's valid.
    151     * @param domain symbolic domain name
    152     * @return true if the symbolic domain name is valid.
    153     */
    154    protected boolean isValidSymbolicDomain(String domain) {
    155        final String[] domainSegment = new String[10]; // CHECKSTYLE IGNORE MagicNumber
    156        boolean match = true;
    157        int i = 0;
    158        final Matcher atomMatcher = ATOM_PATTERN.matcher(domain);
    159        while (match) {
    160            match = atomMatcher.matches();
    161            if (match) {
    162                domainSegment[i] = atomMatcher.group(1);
    163                final int l = domainSegment[i].length() + 1;
    164                domain =
    165                        l >= domain.length()
    166                        ? ""
    167                        : domain.substring(l);
    168
    169                i++;
    170            }
    171        }
    172
    173        final int len = i;
    174
    175        // Make sure there's a host name preceding the domain.
    176        if (len < 2) {
    177            return false;
    178        }
    179
    180        final String tld = domainSegment[len - 1];
    181        if (tld.length() <= 1 || ! TLD_PATTERN.matcher(tld).matches()) {
    182            return false;
    183        }
    184
    185        return true;
    186    }
    187
    188    /**
    189     * Returns true if the user component of an email address is valid.
    190     * @param user being validated
    191     * @return true if the username is valid.
    192     */
    193    protected boolean isValidUser(final String user) {
    194        return USER_PATTERN.matcher(user).matches();
    195    }
    196
    197    /**
    198     * Recursively remove comments, and replace with a single space. The simpler regexps in the Email Addressing FAQ are imperfect - they will miss escaped
    199     * chars in atoms, for example. Derived From Mail::RFC822::Address
    200     *
    201     * @param emailStr The email address
    202     * @return address with comments removed.
    203     */
    204    protected String stripComments(final String emailStr) {
    205        String result = emailStr;
    206        final String commentPat = "^((?:[^\"\\\\]|\\\\.)*(?:\"(?:[^\"\\\\]|\\\\.)*\"(?:[^\"\\\\]|\111111\\\\.)*)*)\\((?:[^()\\\\]|\\\\.)*\\)/";
    207        final Pattern commentMatcher = Pattern.compile(commentPat);
    208
    209        while (commentMatcher.matcher(result).matches()) {
    210            result = result.replaceFirst(commentPat, "\1 ");
    211        }
    212        return result;
    213    }
    214}