f46b7a1884d005f2855ca342080074c2776b8f35
[idea/community.git] / platform / util / src / com / intellij / util / io / URLUtil.java
1 /*
2  * Copyright 2000-2014 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.util.io;
17
18 import com.intellij.openapi.util.Pair;
19 import com.intellij.openapi.util.io.FileUtil;
20 import com.intellij.openapi.util.text.StringUtil;
21 import com.intellij.openapi.vfs.CharsetToolkit;
22 import com.intellij.util.Base64Converter;
23 import gnu.trove.TIntArrayList;
24 import org.jetbrains.annotations.NonNls;
25 import org.jetbrains.annotations.NotNull;
26 import org.jetbrains.annotations.Nullable;
27
28 import java.io.FileNotFoundException;
29 import java.io.FilterInputStream;
30 import java.io.IOException;
31 import java.io.InputStream;
32 import java.net.MalformedURLException;
33 import java.net.URL;
34 import java.util.regex.Matcher;
35 import java.util.regex.Pattern;
36 import java.util.zip.ZipEntry;
37 import java.util.zip.ZipFile;
38
39 import static com.intellij.openapi.util.text.StringUtil.stripQuotesAroundValue;
40
41 public class URLUtil {
42   public static final String SCHEME_SEPARATOR = "://";
43   public static final String FILE_PROTOCOL = "file";
44   public static final String HTTP_PROTOCOL = "http";
45   public static final String JAR_PROTOCOL = "jar";
46   public static final String JAR_SEPARATOR = "!/";
47
48   public static final Pattern DATA_URI_PATTERN = Pattern.compile("data:([^,;]+/[^,;]+)(;charset=[^,;]+)?(;base64)?,(.+)");
49
50   private URLUtil() { }
51
52   /**
53    * Opens a url stream. The semantics is the sames as {@link java.net.URL#openStream()}. The
54    * separate method is needed, since jar URLs open jars via JarFactory and thus keep them
55    * mapped into memory.
56    */
57   @NotNull
58   public static InputStream openStream(@NotNull URL url) throws IOException {
59     @NonNls String protocol = url.getProtocol();
60     return protocol.equals(JAR_PROTOCOL) ? openJarStream(url) : url.openStream();
61   }
62
63   @NotNull
64   public static InputStream openResourceStream(final URL url) throws IOException {
65     try {
66       return openStream(url);
67     }
68     catch(FileNotFoundException ex) {
69       @NonNls final String protocol = url.getProtocol();
70       String file = null;
71       if (protocol.equals(FILE_PROTOCOL)) {
72         file = url.getFile();
73       }
74       else if (protocol.equals(JAR_PROTOCOL)) {
75         int pos = url.getFile().indexOf("!");
76         if (pos >= 0) {
77           file = url.getFile().substring(pos+1);
78         }
79       }
80       if (file != null && file.startsWith("/")) {
81         InputStream resourceStream = URLUtil.class.getResourceAsStream(file);
82         if (resourceStream != null) return resourceStream;
83       }
84       throw ex;
85     }
86   }
87
88   @NotNull
89   private static InputStream openJarStream(@NotNull URL url) throws IOException {
90     Pair<String, String> paths = splitJarUrl(url.getFile());
91     if (paths == null) {
92       throw new MalformedURLException(url.getFile());
93     }
94
95     @SuppressWarnings("IOResourceOpenedButNotSafelyClosed") final ZipFile zipFile = new ZipFile(FileUtil.unquote(paths.first));
96     ZipEntry zipEntry = zipFile.getEntry(paths.second);
97     if (zipEntry == null) {
98       zipFile.close();
99       throw new FileNotFoundException("Entry " + paths.second + " not found in " + paths.first);
100     }
101
102     return new FilterInputStream(zipFile.getInputStream(zipEntry)) {
103         @Override
104         public void close() throws IOException {
105           super.close();
106           zipFile.close();
107         }
108       };
109   }
110
111   /**
112    * Splits .jar URL along a separator and strips "jar" and "file" prefixes if any.
113    * Returns a pair of path to a .jar file and entry name inside a .jar, or null if the URL does not contain a separator.
114    *
115    * E.g. "jar:file:///path/to/jar.jar!/resource.xml" is converted into ["/path/to/jar.jar", "resource.xml"].
116    */
117   @Nullable
118   public static Pair<String, String> splitJarUrl(@NotNull String url) {
119     int pivot = url.indexOf(JAR_SEPARATOR);
120     if (pivot < 0) return null;
121
122     String resourcePath = url.substring(pivot + 2);
123     String jarPath = url.substring(0, pivot);
124
125     if (StringUtil.startsWithConcatenation(jarPath, JAR_PROTOCOL, ":")) {
126       jarPath = jarPath.substring(JAR_PROTOCOL.length() + 1);
127     }
128
129     if (jarPath.startsWith(FILE_PROTOCOL)) {
130       jarPath = jarPath.substring(FILE_PROTOCOL.length());
131       if (jarPath.startsWith(SCHEME_SEPARATOR)) {
132         jarPath = jarPath.substring(SCHEME_SEPARATOR.length());
133       }
134       else if (StringUtil.startsWithChar(jarPath, ':')) {
135         jarPath = jarPath.substring(1);
136       }
137     }
138
139     return Pair.create(jarPath, resourcePath);
140   }
141
142   @NotNull
143   public static String unescapePercentSequences(@NotNull String s) {
144     if (s.indexOf('%') == -1) {
145       return s;
146     }
147
148     StringBuilder decoded = new StringBuilder();
149     final int len = s.length();
150     int i = 0;
151     while (i < len) {
152       char c = s.charAt(i);
153       if (c == '%') {
154         TIntArrayList bytes = new TIntArrayList();
155         while (i + 2 < len && s.charAt(i) == '%') {
156           final int d1 = decode(s.charAt(i + 1));
157           final int d2 = decode(s.charAt(i + 2));
158           if (d1 != -1 && d2 != -1) {
159             bytes.add(((d1 & 0xf) << 4 | d2 & 0xf));
160             i += 3;
161           }
162           else {
163             break;
164           }
165         }
166         if (!bytes.isEmpty()) {
167           final byte[] bytesArray = new byte[bytes.size()];
168           for (int j = 0; j < bytes.size(); j++) {
169             bytesArray[j] = (byte)bytes.getQuick(j);
170           }
171           decoded.append(new String(bytesArray, CharsetToolkit.UTF8_CHARSET));
172           continue;
173         }
174       }
175
176       decoded.append(c);
177       i++;
178     }
179     return decoded.toString();
180   }
181
182   private static int decode(char c) {
183       if ((c >= '0') && (c <= '9'))
184           return c - '0';
185       if ((c >= 'a') && (c <= 'f'))
186           return c - 'a' + 10;
187       if ((c >= 'A') && (c <= 'F'))
188           return c - 'A' + 10;
189       return -1;
190   }
191
192   public static boolean containsScheme(@NotNull String url) {
193     return url.contains(SCHEME_SEPARATOR);
194   }
195
196   public static boolean isDataUri(@NotNull String value) {
197     return !value.isEmpty() && value.startsWith("data:", value.charAt(0) == '"' || value.charAt(0) == '\'' ? 1 : 0);
198   }
199
200   /**
201    * Extracts byte array from given data:URL string.
202    * data:URL will be decoded from base64 if it contains the marker of base64 encoding.
203    *
204    * @param dataUrl data:URL-like string (may be quoted)
205    * @return extracted byte array or {@code null} if it cannot be extracted.
206    */
207   @Nullable
208   public static byte[] getBytesFromDataUri(@NotNull String dataUrl) {
209     Matcher matcher = DATA_URI_PATTERN.matcher(stripQuotesAroundValue(dataUrl));
210     if (matcher.matches()) {
211       try {
212         String content = matcher.group(4);
213         return ";base64".equalsIgnoreCase(matcher.group(3)) ? Base64Converter.decode(content.getBytes(CharsetToolkit.UTF8_CHARSET)) : content.getBytes(CharsetToolkit.UTF8_CHARSET);
214       }
215       catch (IllegalArgumentException e) {
216         return null;
217       }
218     }
219     return null;
220   }
221 }