%line	%branch
org.apache.commons.validator.UrlValidator	92%	99%

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.apache.commons.validator;
18
19		import java.io.Serializable;
20		import java.util.Arrays;
21		import java.util.HashSet;
22		import java.util.Set;
23
24		import org.apache.commons.validator.util.Flags;
25		import org.apache.oro.text.perl.Perl5Util;
26
27		/**
28		* <p>Validates URLs.</p>
29		* Behavour of validation is modified by passing in options:
30		* <li>ALLOW_2_SLASHES - [FALSE] Allows double '/' characters in the path
31		* component.</li>
32		* <li>NO_FRAGMENT- [FALSE] By default fragments are allowed, if this option is
33		* included then fragments are flagged as illegal.</li>
34		* <li>ALLOW_ALL_SCHEMES - [FALSE] By default only http, https, and ftp are
35		* considered valid schemes. Enabling this option will let any scheme pass validation.</li>
36		*
37		* <p>Originally based in on php script by Debbie Dyer, validation.php v1.2b, Date: 03/07/02,
38		* http://javascript.internet.com. However, this validation now bears little resemblance
39		* to the php original.</p>
40		* <pre>
41		* Example of usage:
42		* Construct a UrlValidator with valid schemes of "http", and "https".
43		*
44		* String[] schemes = {"http","https"}.
45		* UrlValidator urlValidator = new UrlValidator(schemes);
46		* if (urlValidator.isValid("ftp://foo.bar.com/")) {
47		* System.out.println("url is valid");
48		* } else {
49		* System.out.println("url is invalid");
50		* }
51		*
52		* prints "url is invalid"
53		* If instead the default constructor is used.
54		*
55		* UrlValidator urlValidator = new UrlValidator();
56		* if (urlValidator.isValid("ftp://foo.bar.com/")) {
57		* System.out.println("url is valid");
58		* } else {
59		* System.out.println("url is invalid");
60		* }
61		*
62		* prints out "url is valid"
63		* </pre>
64		*
65		* @see
66		* <a href='http://www.ietf.org/rfc/rfc2396.txt' >
67		* Uniform Resource Identifiers (URI): Generic Syntax
68		* </a>
69		*
70		* @version $Revision: 478334 $ $Date: 2006-11-22 21:31:54 +0000 (Wed, 22 Nov 2006) $
71		* @since Validator 1.1
72		*/
73		public class UrlValidator implements Serializable {
74
75		/**
76		* Allows all validly formatted schemes to pass validation instead of
77		* supplying a set of valid schemes.
78		*/
79		public static final int ALLOW_ALL_SCHEMES = 1 << 0;
80
81		/**
82		* Allow two slashes in the path component of the URL.
83		*/
84		public static final int ALLOW_2_SLASHES = 1 << 1;
85
86		/**
87		* Enabling this options disallows any URL fragments.
88		*/
89		public static final int NO_FRAGMENTS = 1 << 2;
90
91		private static final String ALPHA_CHARS = "a-zA-Z";
92
93		private static final String ALPHA_NUMERIC_CHARS = ALPHA_CHARS + "\\d";
94
95		private static final String SPECIAL_CHARS = ";/@&=,.?:+$";
96
97		private static final String VALID_CHARS = "[^\\s" + SPECIAL_CHARS + "]";
98
99		private static final String SCHEME_CHARS = ALPHA_CHARS;
100
101		// Drop numeric, and "+-." for now
102		private static final String AUTHORITY_CHARS = ALPHA_NUMERIC_CHARS + "\\-\\.";
103
104		private static final String ATOM = VALID_CHARS + '+';
105
106		/**
107		* This expression derived/taken from the BNF for URI (RFC2396).
108		*/
109		private static final String URL_PATTERN =
110		"/^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/";
111		// 12 3 4 5 6 7 8 9
112
113		/**
114		* Schema/Protocol (ie. http:, ftp:, file:, etc).
115		*/
116		private static final int PARSE_URL_SCHEME = 2;
117
118		/**
119		* Includes hostname/ip and port number.
120		*/
121		private static final int PARSE_URL_AUTHORITY = 4;
122
123		private static final int PARSE_URL_PATH = 5;
124
125		private static final int PARSE_URL_QUERY = 7;
126
127		private static final int PARSE_URL_FRAGMENT = 9;
128
129		/**
130		* Protocol (ie. http:, ftp:,https:).
131		*/
132		private static final String SCHEME_PATTERN = "/^[" + SCHEME_CHARS + "]/";
133
134		private static final String AUTHORITY_PATTERN =
135		"/^([" + AUTHORITY_CHARS + "]*)(:\\d*)?(.*)?/";
136		// 1 2 3 4
137
138		private static final int PARSE_AUTHORITY_HOST_IP = 1;
139
140		private static final int PARSE_AUTHORITY_PORT = 2;
141
142		/**
143		* Should always be empty.
144		*/
145		private static final int PARSE_AUTHORITY_EXTRA = 3;
146
147		private static final String PATH_PATTERN = "/^(/[-\\w:@&?=+,.!/~*'%$_;]*)?$/";
148
149		private static final String QUERY_PATTERN = "/^(.*)$/";
150
151		private static final String LEGAL_ASCII_PATTERN = "/^[\\000-\\177]+$/";
152
153		private static final String IP_V4_DOMAIN_PATTERN =
154		"/^(\\d{1,3})[.](\\d{1,3})[.](\\d{1,3})[.](\\d{1,3})$/";
155
156		private static final String DOMAIN_PATTERN =
157		"/^" + ATOM + "(\\." + ATOM + ")*$/";
158
159		private static final String PORT_PATTERN = "/^:(\\d{1,5})$/";
160
161		private static final String ATOM_PATTERN = "/(" + ATOM + ")/";
162
163		private static final String ALPHA_PATTERN = "/^[" + ALPHA_CHARS + "]/";
164
165		/**
166		* Holds the set of current validation options.
167		*/
168	20	private Flags options = null;
169
170		/**
171		* The set of schemes that are allowed to be in a URL.
172		*/
173	20	private Set allowedSchemes = new HashSet();
174
175		/**
176		* If no schemes are provided, default to this set.
177		*/
178	20	protected String[] defaultSchemes = {"http", "https", "ftp"};
179
180		/**
181		* Create a UrlValidator with default properties.
182		*/
183		public UrlValidator() {
184	15	this(null);
185	15	}
186
187		/**
188		* Behavior of validation is modified by passing in several strings options:
189		* @param schemes Pass in one or more url schemes to consider valid, passing in
190		* a null will default to "http,https,ftp" being valid.
191		* If a non-null schemes is specified then all valid schemes must
192		* be specified. Setting the ALLOW_ALL_SCHEMES option will
193		* ignore the contents of schemes.
194		*/
195		public UrlValidator(String[] schemes) {
196	16	this(schemes, 0);
197	16	}
198
199		/**
200		* Initialize a UrlValidator with the given validation options.
201		* @param options The options should be set using the public constants declared in
202		* this class. To set multiple options you simply add them together. For example,
203		* ALLOW_2_SLASHES + NO_FRAGMENTS enables both of those options.
204		*/
205		public UrlValidator(int options) {
206	0	this(null, options);
207	0	}
208
209		/**
210		* Behavour of validation is modified by passing in options:
211		* @param schemes The set of valid schemes.
212		* @param options The options should be set using the public constants declared in
213		* this class. To set multiple options you simply add them together. For example,
214		* ALLOW_2_SLASHES + NO_FRAGMENTS enables both of those options.
215		*/
216	20	public UrlValidator(String[] schemes, int options) {
217	20	this.options = new Flags(options);
218
219	20	if (this.options.isOn(ALLOW_ALL_SCHEMES)) {
220	2	return;
221		}
222
223	18	if (schemes == null) {
224	15	schemes = this.defaultSchemes;
225		}
226
227	18	this.allowedSchemes.addAll(Arrays.asList(schemes));
228	18	}
229
230		/**
231		* <p>Checks if a field has a valid url address.</p>
232		*
233		* @param value The value validation is being performed on. A <code>null</code>
234		* value is considered invalid.
235		* @return true if the url is valid.
236		*/
237		public boolean isValid(String value) {
238	75606	if (value == null) {
239	0	return false;
240		}
241
242	75606	Perl5Util matchUrlPat = new Perl5Util();
243	75606	Perl5Util matchAsciiPat = new Perl5Util();
244
245	75606	if (!matchAsciiPat.match(LEGAL_ASCII_PATTERN, value)) {
246	0	return false;
247		}
248
249		// Check the whole url address structure
250	75606	if (!matchUrlPat.match(URL_PATTERN, value)) {
251	0	return false;
252		}
253
254	75606	if (!isValidScheme(matchUrlPat.group(PARSE_URL_SCHEME))) {
255	28350	return false;
256		}
257
258	47256	if (!isValidAuthority(matchUrlPat.group(PARSE_URL_AUTHORITY))) {
259	39375	return false;
260		}
261
262	7881	if (!isValidPath(matchUrlPat.group(PARSE_URL_PATH))) {
263	2520	return false;
264		}
265
266	5361	if (!isValidQuery(matchUrlPat.group(PARSE_URL_QUERY))) {
267	0	return false;
268		}
269
270	5361	if (!isValidFragment(matchUrlPat.group(PARSE_URL_FRAGMENT))) {
271	630	return false;
272		}
273
274	4731	return true;
275		}
276
277		/**
278		* Validate scheme. If schemes[] was initialized to a non null,
279		* then only those scheme's are allowed. Note this is slightly different
280		* than for the constructor.
281		* @param scheme The scheme to validate. A <code>null</code> value is considered
282		* invalid.
283		* @return true if valid.
284		*/
285		protected boolean isValidScheme(String scheme) {
286	75610	if (scheme == null) {
287	18900	return false;
288		}
289
290	56710	Perl5Util schemeMatcher = new Perl5Util();
291	56710	if (!schemeMatcher.match(SCHEME_PATTERN, scheme)) {
292	9450	return false;
293		}
294
295	47260	if (this.options.isOff(ALLOW_ALL_SCHEMES)) {
296
297	6	if (!this.allowedSchemes.contains(scheme)) {
298	3	return false;
299		}
300		}
301
302	47257	return true;
303		}
304
305		/**
306		* Returns true if the authority is properly formatted. An authority is the combination
307		* of hostname and port. A <code>null</code> authority value is considered invalid.
308		* @param authority Authority value to validate.
309		* @return true if authority (hostname and port) is valid.
310		*/
311		protected boolean isValidAuthority(String authority) {
312	47256	if (authority == null) {
313	18831	return false;
314		}
315
316	28425	Perl5Util authorityMatcher = new Perl5Util();
317	28425	Perl5Util matchIPV4Pat = new Perl5Util();
318
319	28425	if (!authorityMatcher.match(AUTHORITY_PATTERN, authority)) {
320	0	return false;
321		}
322
323	28425	boolean ipV4Address = false;
324	28425	boolean hostname = false;
325		// check if authority is IP address or hostname
326	28425	String hostIP = authorityMatcher.group(PARSE_AUTHORITY_HOST_IP);
327	28425	ipV4Address = matchIPV4Pat.match(IP_V4_DOMAIN_PATTERN, hostIP);
328
329	28425	if (ipV4Address) {
330		// this is an IP address so check components
331	17325	for (int i = 1; i <= 4; i++) {
332	14175	String ipSegment = matchIPV4Pat.group(i);
333	14175	if (ipSegment == null || ipSegment.length() <= 0) {
334	0	return false;
335		}
336
337		try {
338	14175	if (Integer.parseInt(ipSegment) > 255) {
339	1575	return false;
340		}
341	12600	} catch(NumberFormatException e) {
342	0	return false;
343		}
344
345		}
346		} else {
347		// Domain is hostname name
348	23700	Perl5Util domainMatcher = new Perl5Util();
349	23700	hostname = domainMatcher.match(DOMAIN_PATTERN, hostIP);
350		}
351
352		//rightmost hostname will never start with a digit.
353	26850	if (hostname) {
354		// LOW-TECH FIX FOR VALIDATOR-202
355		// TODO: Rewrite to use ArrayList and .add semantics: see VALIDATOR-203
356	15789	char[] class="keyword">chars = hostIP.toCharArray();
357	15789	int size = 1;
358	118890	for(int i=0; i<chars.length; i++) {
359	103101	if(chars[i] == '.') {
360	22119	size++;
361		}
362		}
363	15789	String[] domainSegment = new String[size];
364	15789	boolean match = true;
365	15789	int segmentCount = 0;
366	15789	int segmentLength = 0;
367	15789	Perl5Util atomMatcher = new Perl5Util();
368
369	85275	while (match) {
370	53697	match = atomMatcher.match(ATOM_PATTERN, hostIP);
371	53697	if (match) {
372	37908	domainSegment[segmentCount] = atomMatcher.group(1);
373	37908	segmentLength = domainSegment[segmentCount].length() + 1;
374	37908	hostIP =
375		(segmentLength >= hostIP.length())
376		? ""
377		: hostIP.substring(segmentLength);
378
379	37908	segmentCount++;
380		}
381		}
382	15789	String topLevel = domainSegment[segmentCount - 1];
383	15789	if (topLevel.length() < 2 || topLevel.length() > 4) {
384	4749	return false;
385		}
386
387		// First letter of top level must be a alpha
388	11040	Perl5Util alphaMatcher = new Perl5Util();
389	11040	if (!alphaMatcher.match(ALPHA_PATTERN, topLevel.substring(0, 1))) {
390	1575	return false;
391		}
392
393		// Make sure there's a host name preceding the authority.
394	9465	if (segmentCount < 2) {
395	1584	return false;
396		}
397		}
398
399	18942	if (!hostname && !ipV4Address) {
400	7911	return false;
401		}
402
403	11031	String port = authorityMatcher.group(PARSE_AUTHORITY_PORT);
404	11031	if (port != null) {
405	9450	Perl5Util portMatcher = new Perl5Util();
406	9450	if (!portMatcher.match(PORT_PATTERN, port)) {
407	1575	return false;
408		}
409		}
410
411	9456	String extra = authorityMatcher.group(PARSE_AUTHORITY_EXTRA);
412	9456	if (!GenericValidator.isBlankOrNull(extra)) {
413	1575	return false;
414		}
415
416	7881	return true;
417		}
418
419		/**
420		* Returns true if the path is valid. A <code>null</code> value is considered invalid.
421		* @param path Path value to validate.
422		* @return true if path is valid.
423		*/
424		protected boolean isValidPath(String path) {
425	7881	if (path == null) {
426	0	return false;
427		}
428
429	7881	Perl5Util pathMatcher = new Perl5Util();
430
431	7881	if (!pathMatcher.match(PATH_PATTERN, path)) {
432	0	return false;
433		}
434
435	7881	int slash2Count = countToken("//", path);
436	7881	if (this.options.isOff(ALLOW_2_SLASHES) && (slash2Count > 0)) {
437	630	return false;
438		}
439
440	7251	int slashCount = countToken("/", path);
441	7251	int dot2Count = countToken("..", path);
442	7251	if (dot2Count > 0) {
443	1890	if ((slashCount - slash2Count - 1) <= dot2Count) {
444	1890	return false;
445		}
446		}
447
448	5361	return true;
449		}
450
451		/**
452		* Returns true if the query is null or it's a properly formatted query string.
453		* @param query Query value to validate.
454		* @return true if query is valid.
455		*/
456		protected boolean isValidQuery(String query) {
457	5361	if (query == null) {
458	2211	return true;
459		}
460
461	3150	Perl5Util queryMatcher = new Perl5Util();
462	3150	return queryMatcher.match(QUERY_PATTERN, query);
463		}
464
465		/**
466		* Returns true if the given fragment is null or fragments are allowed.
467		* @param fragment Fragment value to validate.
468		* @return true if fragment is valid.
469		*/
470		protected boolean isValidFragment(String fragment) {
471	5361	if (fragment == null) {
472	4731	return true;
473		}
474
475	630	return this.options.isOff(NO_FRAGMENTS);
476		}
477
478		/**
479		* Returns the number of times the token appears in the target.
480		* @param token Token value to be counted.
481		* @param target Target value to count tokens in.
482		* @return the number of tokens.
483		*/
484		protected int countToken(String token, String target) {
485	22383	int tokenIndex = 0;
486	22383	int count = 0;
487	81014	while (tokenIndex != -1) {
488	36248	tokenIndex = target.indexOf(token, tokenIndex);
489	36248	if (tokenIndex > -1) {
490	13865	tokenIndex++;
491	13865	count++;
492		}
493		}
494	22383	return count;
495		}
496		}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.