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     *
069     * @return singleton instance of this validator.
070     */
071    public static EmailValidator getInstance() {
072        return EMAIL_VALIDATOR;
073    }
074
075    /**
076     * Protected constructor for subclasses to use.
077     */
078    protected EmailValidator() {
079    }
080
081    /**
082     * <p>Checks if a field has a valid e-mail address.</p>
083     *
084     * @param email The value validation is being performed on.  A {@code null}
085     * value is considered invalid.
086     * @return true if the email address is valid.
087     */
088    public boolean isValid(final String email) {
089        return org.apache.commons.validator.routines.EmailValidator.getInstance().isValid(email);
090    }
091
092    /**
093     * Returns true if the domain component of an email address is valid.
094     *
095     * @param domain being validated.
096     * @return true if the email address's domain is valid.
097     */
098    protected boolean isValidDomain(final String domain) {
099        boolean symbolic = false;
100
101        // see if domain is an IP address in brackets
102        final Matcher ipDomainMatcher = IP_DOMAIN_PATTERN.matcher(domain);
103
104        if (ipDomainMatcher.matches()) {
105            final InetAddressValidator inetAddressValidator =
106                    InetAddressValidator.getInstance();
107            if (inetAddressValidator.isValid(ipDomainMatcher.group(1))) {
108                return true;
109            }
110        } else {
111            // Domain is symbolic name
112            symbolic = DOMAIN_PATTERN.matcher(domain).matches();
113        }
114
115        if (!symbolic || !isValidSymbolicDomain(domain)) {
116            return false;
117        }
118
119        return true;
120    }
121
122    /**
123     * Validates an IP address. Returns true if valid.
124     *
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     *
155     * @param domain symbolic domain name
156     * @return true if the symbolic domain name is valid.
157     */
158    protected boolean isValidSymbolicDomain(String domain) {
159        final String[] domainSegment = new String[10]; // CHECKSTYLE IGNORE MagicNumber
160        boolean match = true;
161        int i = 0;
162        final Matcher atomMatcher = ATOM_PATTERN.matcher(domain);
163        while (match) {
164            match = atomMatcher.matches();
165            if (match) {
166                domainSegment[i] = atomMatcher.group(1);
167                final int l = domainSegment[i].length() + 1;
168                domain =
169                        l >= domain.length()
170                        ? ""
171                        : domain.substring(l);
172
173                i++;
174            }
175        }
176
177        final int len = i;
178
179        // Make sure there's a host name preceding the domain.
180        if (len < 2) {
181            return false;
182        }
183
184        final String tld = domainSegment[len - 1];
185        if (tld.length() <= 1 || ! TLD_PATTERN.matcher(tld).matches()) {
186            return false;
187        }
188
189        return true;
190    }
191
192    /**
193     * Returns true if the user component of an email address is valid.
194     *
195     * @param user being validated
196     * @return true if the username is valid.
197     */
198    protected boolean isValidUser(final String user) {
199        return USER_PATTERN.matcher(user).matches();
200    }
201
202    /**
203     * Recursively remove comments, and replace with a single space. The simpler regexps in the Email Addressing FAQ are imperfect - they will miss escaped
204     * chars in atoms, for example. Derived From Mail::RFC822::Address
205     *
206     * @param emailStr The email address
207     * @return address with comments removed.
208     */
209    protected String stripComments(final String emailStr) {
210        String result = emailStr;
211        final String commentPat = "^((?:[^\"\\\\]|\\\\.)*(?:\"(?:[^\"\\\\]|\\\\.)*\"(?:[^\"\\\\]|\111111\\\\.)*)*)\\((?:[^()\\\\]|\\\\.)*\\)/";
212        final Pattern commentMatcher = Pattern.compile(commentPat);
213
214        while (commentMatcher.matcher(result).matches()) {
215            result = result.replaceFirst(commentPat, "\1 ");
216        }
217        return result;
218    }
219}