1 //
2 // ========================================================================
3 // Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
4 // ------------------------------------------------------------------------
5 // All rights reserved. This program and the accompanying materials
6 // are made available under the terms of the Eclipse Public License v1.0
7 // and Apache License v2.0 which accompanies this distribution.
8 //
9 // The Eclipse Public License is available at
10 // http://www.eclipse.org/legal/epl-v10.html
11 //
12 // The Apache License v2.0 is available at
13 // http://www.opensource.org/licenses/apache2.0.php
14 //
15 // You may elect to redistribute this code under either of these licenses.
16 // ========================================================================
17 //
18
19 package org.eclipse.jetty.util;
20
21 import java.io.UnsupportedEncodingException;
22 import java.net.URI;
23 import java.net.URLEncoder;
24
25 import org.eclipse.jetty.util.log.Log;
26
27
28
29 /* ------------------------------------------------------------ */
30 /** URI Holder.
31 * This class assists with the decoding and encoding or HTTP URI's.
32 * It differs from the java.net.URL class as it does not provide
33 * communications ability, but it does assist with query string
34 * formatting.
35 * <P>UTF-8 encoding is used by default for % encoded characters. This
36 * may be overridden with the org.eclipse.jetty.util.URI.charset system property.
37 * @see UrlEncoded
38 *
39 */
40 public class URIUtil
41 implements Cloneable
42 {
43 public static final String SLASH="/";
44 public static final String HTTP="http";
45 public static final String HTTP_COLON="http:";
46 public static final String HTTPS="https";
47 public static final String HTTPS_COLON="https:";
48
49 // Use UTF-8 as per http://www.w3.org/TR/html40/appendix/notes.html#non-ascii-chars
50 public static final String __CHARSET=System.getProperty("org.eclipse.jetty.util.URI.charset",StringUtil.__UTF8);
51
52 private URIUtil()
53 {}
54
55 /* ------------------------------------------------------------ */
56 /** Encode a URI path.
57 * This is the same encoding offered by URLEncoder, except that
58 * the '/' character is not encoded.
59 * @param path The path the encode
60 * @return The encoded path
61 */
62 public static String encodePath(String path)
63 {
64 if (path==null || path.length()==0)
65 return path;
66
67 StringBuilder buf = encodePath(null,path);
68 return buf==null?path:buf.toString();
69 }
70
71 /* ------------------------------------------------------------ */
72 /** Encode a URI path.
73 * @param path The path the encode
74 * @param buf StringBuilder to encode path into (or null)
75 * @return The StringBuilder or null if no substitutions required.
76 */
77 public static StringBuilder encodePath(StringBuilder buf, String path)
78 {
79 byte[] bytes=null;
80 if (buf==null)
81 {
82 loop:
83 for (int i=0;i<path.length();i++)
84 {
85 char c=path.charAt(i);
86 switch(c)
87 {
88 case '%':
89 case '?':
90 case ';':
91 case '#':
92 case '\'':
93 case '"':
94 case '<':
95 case '>':
96 case ' ':
97 buf=new StringBuilder(path.length()*2);
98 break loop;
99 default:
100 if (c>127)
101 {
102 try
103 {
104 bytes=path.getBytes(URIUtil.__CHARSET);
105 }
106 catch (UnsupportedEncodingException e)
107 {
108 throw new IllegalStateException(e);
109 }
110 buf=new StringBuilder(path.length()*2);
111 break loop;
112 }
113
114 }
115 }
116 if (buf==null)
117 return null;
118 }
119
120 synchronized(buf)
121 {
122 if (bytes!=null)
123 {
124 for (int i=0;i<bytes.length;i++)
125 {
126 byte c=bytes[i];
127 switch(c)
128 {
129 case '%':
130 buf.append("%25");
131 continue;
132 case '?':
133 buf.append("%3F");
134 continue;
135 case ';':
136 buf.append("%3B");
137 continue;
138 case '#':
139 buf.append("%23");
140 continue;
141 case '"':
142 buf.append("%22");
143 continue;
144 case '\'':
145 buf.append("%27");
146 continue;
147 case '<':
148 buf.append("%3C");
149 continue;
150 case '>':
151 buf.append("%3E");
152 continue;
153 case ' ':
154 buf.append("%20");
155 continue;
156 default:
157 if (c<0)
158 {
159 buf.append('%');
160 TypeUtil.toHex(c,buf);
161 }
162 else
163 buf.append((char)c);
164 continue;
165 }
166 }
167
168 }
169 else
170 {
171 for (int i=0;i<path.length();i++)
172 {
173 char c=path.charAt(i);
174 switch(c)
175 {
176 case '%':
177 buf.append("%25");
178 continue;
179 case '?':
180 buf.append("%3F");
181 continue;
182 case ';':
183 buf.append("%3B");
184 continue;
185 case '#':
186 buf.append("%23");
187 continue;
188 case '"':
189 buf.append("%22");
190 continue;
191 case '\'':
192 buf.append("%27");
193 continue;
194 case '<':
195 buf.append("%3C");
196 continue;
197 case '>':
198 buf.append("%3E");
199 continue;
200 case ' ':
201 buf.append("%20");
202 continue;
203 default:
204 buf.append(c);
205 continue;
206 }
207 }
208 }
209 }
210
211 return buf;
212 }
213
214 /* ------------------------------------------------------------ */
215 /** Encode a URI path.
216 * @param path The path the encode
217 * @param buf StringBuilder to encode path into (or null)
218 * @param encode String of characters to encode. % is always encoded.
219 * @return The StringBuilder or null if no substitutions required.
220 */
221 public static StringBuilder encodeString(StringBuilder buf,
222 String path,
223 String encode)
224 {
225 if (buf==null)
226 {
227 loop:
228 for (int i=0;i<path.length();i++)
229 {
230 char c=path.charAt(i);
231 if (c=='%' || encode.indexOf(c)>=0)
232 {
233 buf=new StringBuilder(path.length()<<1);
234 break loop;
235 }
236 }
237 if (buf==null)
238 return null;
239 }
240
241 synchronized(buf)
242 {
243 for (int i=0;i<path.length();i++)
244 {
245 char c=path.charAt(i);
246 if (c=='%' || encode.indexOf(c)>=0)
247 {
248 buf.append('%');
249 StringUtil.append(buf,(byte)(0xff&c),16);
250 }
251 else
252 buf.append(c);
253 }
254 }
255
256 return buf;
257 }
258
259 /* ------------------------------------------------------------ */
260 /* Decode a URI path and strip parameters
261 * @param path The path the encode
262 * @param buf StringBuilder to encode path into
263 */
264 public static String decodePath(String path)
265 {
266 if (path==null)
267 return null;
268 // Array to hold all converted characters
269 char[] chars=null;
270 int n=0;
271 // Array to hold a sequence of %encodings
272 byte[] bytes=null;
273 int b=0;
274
275 int len=path.length();
276
277 for (int i=0;i<len;i++)
278 {
279 char c = path.charAt(i);
280
281 if (c=='%' && (i+2)<len)
282 {
283 if (chars==null)
284 {
285 chars=new char[len];
286 bytes=new byte[len];
287 path.getChars(0,i,chars,0);
288 }
289 bytes[b++]=(byte)(0xff&TypeUtil.parseInt(path,i+1,2,16));
290 i+=2;
291 continue;
292 }
293 else if (c==';')
294 {
295 if (chars==null)
296 {
297 chars=new char[len];
298 path.getChars(0,i,chars,0);
299 n=i;
300 }
301 break;
302 }
303 else if (bytes==null)
304 {
305 n++;
306 continue;
307 }
308
309 // Do we have some bytes to convert?
310 if (b>0)
311 {
312 // convert series of bytes and add to chars
313 String s;
314 try
315 {
316 s=new String(bytes,0,b,__CHARSET);
317 }
318 catch (UnsupportedEncodingException e)
319 {
320 s=new String(bytes,0,b);
321 }
322 s.getChars(0,s.length(),chars,n);
323 n+=s.length();
324 b=0;
325 }
326
327 chars[n++]=c;
328 }
329
330 if (chars==null)
331 return path;
332
333 // if we have a remaining sequence of bytes
334 if (b>0)
335 {
336 // convert series of bytes and add to chars
337 String s;
338 try
339 {
340 s=new String(bytes,0,b,__CHARSET);
341 }
342 catch (UnsupportedEncodingException e)
343 {
344 s=new String(bytes,0,b);
345 }
346 s.getChars(0,s.length(),chars,n);
347 n+=s.length();
348 }
349
350 return new String(chars,0,n);
351 }
352
353 /* ------------------------------------------------------------ */
354 /* Decode a URI path and strip parameters.
355 * @param path The path the encode
356 * @param buf StringBuilder to encode path into
357 */
358 public static String decodePath(byte[] buf, int offset, int length)
359 {
360 byte[] bytes=null;
361 int n=0;
362
363 for (int i=0;i<length;i++)
364 {
365 byte b = buf[i + offset];
366
367 if (b=='%' && (i+2)<length)
368 {
369 b=(byte)(0xff&TypeUtil.parseInt(buf,i+offset+1,2,16));
370 i+=2;
371 }
372 else if (b==';')
373 {
374 length=i;
375 break;
376 }
377 else if (bytes==null)
378 {
379 n++;
380 continue;
381 }
382
383 if (bytes==null)
384 {
385 bytes=new byte[length];
386 for (int j=0;j<n;j++)
387 bytes[j]=buf[j + offset];
388 }
389
390 bytes[n++]=b;
391 }
392
393 if (bytes==null)
394 return StringUtil.toString(buf,offset,length,__CHARSET);
395 return StringUtil.toString(bytes,0,n,__CHARSET);
396 }
397
398
399 /* ------------------------------------------------------------ */
400 /** Add two URI path segments.
401 * Handles null and empty paths, path and query params (eg ?a=b or
402 * ;JSESSIONID=xxx) and avoids duplicate '/'
403 * @param p1 URI path segment (should be encoded)
404 * @param p2 URI path segment (should be encoded)
405 * @return Legally combined path segments.
406 */
407 public static String addPaths(String p1, String p2)
408 {
409 if (p1==null || p1.length()==0)
410 {
411 if (p1!=null && p2==null)
412 return p1;
413 return p2;
414 }
415 if (p2==null || p2.length()==0)
416 return p1;
417
418 int split=p1.indexOf(';');
419 if (split<0)
420 split=p1.indexOf('?');
421 if (split==0)
422 return p2+p1;
423 if (split<0)
424 split=p1.length();
425
426 StringBuilder buf = new StringBuilder(p1.length()+p2.length()+2);
427 buf.append(p1);
428
429 if (buf.charAt(split-1)=='/')
430 {
431 if (p2.startsWith(URIUtil.SLASH))
432 {
433 buf.deleteCharAt(split-1);
434 buf.insert(split-1,p2);
435 }
436 else
437 buf.insert(split,p2);
438 }
439 else
440 {
441 if (p2.startsWith(URIUtil.SLASH))
442 buf.insert(split,p2);
443 else
444 {
445 buf.insert(split,'/');
446 buf.insert(split+1,p2);
447 }
448 }
449
450 return buf.toString();
451 }
452
453 /* ------------------------------------------------------------ */
454 /** Return the parent Path.
455 * Treat a URI like a directory path and return the parent directory.
456 */
457 public static String parentPath(String p)
458 {
459 if (p==null || URIUtil.SLASH.equals(p))
460 return null;
461 int slash=p.lastIndexOf('/',p.length()-2);
462 if (slash>=0)
463 return p.substring(0,slash+1);
464 return null;
465 }
466
467 /* ------------------------------------------------------------ */
468 /** Convert a path to a cananonical form.
469 * All instances of "." and ".." are factored out. Null is returned
470 * if the path tries to .. above its root.
471 * @param path
472 * @return path or null.
473 */
474 public static String canonicalPath(String path)
475 {
476 if (path==null || path.length()==0)
477 return path;
478
479 int end=path.length();
480 int start = path.lastIndexOf('/', end);
481
482 search:
483 while (end>0)
484 {
485 switch(end-start)
486 {
487 case 2: // possible single dot
488 if (path.charAt(start+1)!='.')
489 break;
490 break search;
491 case 3: // possible double dot
492 if (path.charAt(start+1)!='.' || path.charAt(start+2)!='.')
493 break;
494 break search;
495 }
496
497 end=start;
498 start=path.lastIndexOf('/',end-1);
499 }
500
501 // If we have checked the entire string
502 if (start>=end)
503 return path;
504
505 StringBuilder buf = new StringBuilder(path);
506 int delStart=-1;
507 int delEnd=-1;
508 int skip=0;
509
510 while (end>0)
511 {
512 switch(end-start)
513 {
514 case 2: // possible single dot
515 if (buf.charAt(start+1)!='.')
516 {
517 if (skip>0 && --skip==0)
518 {
519 delStart=start>=0?start:0;
520 if(delStart>0 && delEnd==buf.length() && buf.charAt(delEnd-1)=='.')
521 delStart++;
522 }
523 break;
524 }
525
526 if(start<0 && buf.length()>2 && buf.charAt(1)=='/' && buf.charAt(2)=='/')
527 break;
528
529 if(delEnd<0)
530 delEnd=end;
531 delStart=start;
532 if (delStart<0 || delStart==0&&buf.charAt(delStart)=='/')
533 {
534 delStart++;
535 if (delEnd<buf.length() && buf.charAt(delEnd)=='/')
536 delEnd++;
537 break;
538 }
539 if (end==buf.length())
540 delStart++;
541
542 end=start--;
543 while (start>=0 && buf.charAt(start)!='/')
544 start--;
545 continue;
546
547 case 3: // possible double dot
548 if (buf.charAt(start+1)!='.' || buf.charAt(start+2)!='.')
549 {
550 if (skip>0 && --skip==0)
551 { delStart=start>=0?start:0;
552 if(delStart>0 && delEnd==buf.length() && buf.charAt(delEnd-1)=='.')
553 delStart++;
554 }
555 break;
556 }
557
558 delStart=start;
559 if (delEnd<0)
560 delEnd=end;
561
562 skip++;
563 end=start--;
564 while (start>=0 && buf.charAt(start)!='/')
565 start--;
566 continue;
567
568 default:
569 if (skip>0 && --skip==0)
570 {
571 delStart=start>=0?start:0;
572 if(delEnd==buf.length() && buf.charAt(delEnd-1)=='.')
573 delStart++;
574 }
575 }
576
577 // Do the delete
578 if (skip<=0 && delStart>=0 && delEnd>=delStart)
579 {
580 buf.delete(delStart,delEnd);
581 delStart=delEnd=-1;
582 if (skip>0)
583 delEnd=end;
584 }
585
586 end=start--;
587 while (start>=0 && buf.charAt(start)!='/')
588 start--;
589 }
590
591 // Too many ..
592 if (skip>0)
593 return null;
594
595 // Do the delete
596 if (delEnd>=0)
597 buf.delete(delStart,delEnd);
598
599 return buf.toString();
600 }
601
602 /* ------------------------------------------------------------ */
603 /** Convert a path to a compact form.
604 * All instances of "//" and "///" etc. are factored out to single "/"
605 * @param path
606 * @return path
607 */
608 public static String compactPath(String path)
609 {
610 if (path==null || path.length()==0)
611 return path;
612
613 int state=0;
614 int end=path.length();
615 int i=0;
616
617 loop:
618 while (i<end)
619 {
620 char c=path.charAt(i);
621 switch(c)
622 {
623 case '?':
624 return path;
625 case '/':
626 state++;
627 if (state==2)
628 break loop;
629 break;
630 default:
631 state=0;
632 }
633 i++;
634 }
635
636 if (state<2)
637 return path;
638
639 StringBuffer buf = new StringBuffer(path.length());
640 buf.append(path,0,i);
641
642 loop2:
643 while (i<end)
644 {
645 char c=path.charAt(i);
646 switch(c)
647 {
648 case '?':
649 buf.append(path,i,end);
650 break loop2;
651 case '/':
652 if (state++==0)
653 buf.append(c);
654 break;
655 default:
656 state=0;
657 buf.append(c);
658 }
659 i++;
660 }
661
662 return buf.toString();
663 }
664
665 /* ------------------------------------------------------------ */
666 /**
667 * @param uri URI
668 * @return True if the uri has a scheme
669 */
670 public static boolean hasScheme(String uri)
671 {
672 for (int i=0;i<uri.length();i++)
673 {
674 char c=uri.charAt(i);
675 if (c==':')
676 return true;
677 if (!(c>='a'&&c<='z' ||
678 c>='A'&&c<='Z' ||
679 (i>0 &&(c>='0'&&c<='9' ||
680 c=='.' ||
681 c=='+' ||
682 c=='-'))
683 ))
684 break;
685 }
686 return false;
687 }
688
689 }
690
691
692