Debian Codegraph @

src/main/java/org/apache/tools/zip/ZipEncodingHelper.java

raw
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 */
18
19 package org.apache.tools.zip;
20
21 import java.nio.ByteBuffer;
22 import java.nio.charset.Charset;
23 import java.nio.charset.UnsupportedCharsetException;
24 import java.util.HashMap;
25 import java.util.Map;
26
27 /**
28 * Static helper functions for robustly encoding filenames in zip files.
29 */
30 @SuppressWarnings({ "unchecked", "rawtypes" })
31 abstract class ZipEncodingHelper {
32
33 /**
34 * A class, which holds the high characters of a simple encoding
35 * and lazily instantiates a Simple8BitZipEncoding instance in a
36 * thread-safe manner.
37 */
38 private static class SimpleEncodingHolder {
39
40 private final char [] highChars;
41 private Simple8BitZipEncoding encoding;
42
43 /**
44 * Instantiate a simple encoding holder.
45 *
46 * @param highChars The characters for byte codes 128 to 255.
47 *
48 * @see Simple8BitZipEncoding#Simple8BitZipEncoding(char[])
49 */
50 SimpleEncodingHolder(char [] highChars) {
51 this.highChars = highChars;
52 }
53
54 /**
55 * @return The associated {@link Simple8BitZipEncoding}, which
56 * is instantiated if not done so far.
57 */
58 public synchronized Simple8BitZipEncoding getEncoding() {
59 if (this.encoding == null) {
60 this.encoding = new Simple8BitZipEncoding(this.highChars);
61 }
62 return this.encoding;
63 }
64 }
65
66 private static final Map simpleEncodings;
67
68 static {
69 simpleEncodings = new HashMap();
70
71 char[] cp437_high_chars =
72 new char[] { 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0,
73 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef,
74 0x00ee, 0x00ec, 0x00c4, 0x00c5, 0x00c9, 0x00e6,
75 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
76 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5,
77 0x20a7, 0x0192, 0x00e1, 0x00ed, 0x00f3, 0x00fa,
78 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x2310,
79 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
80 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561,
81 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557,
82 0x255d, 0x255c, 0x255b, 0x2510, 0x2514, 0x2534,
83 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
84 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550,
85 0x256c, 0x2567, 0x2568, 0x2564, 0x2565, 0x2559,
86 0x2558, 0x2552, 0x2553, 0x256b, 0x256a, 0x2518,
87 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
88 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3,
89 0x00b5, 0x03c4, 0x03a6, 0x0398, 0x03a9, 0x03b4,
90 0x221e, 0x03c6, 0x03b5, 0x2229, 0x2261, 0x00b1,
91 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
92 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2,
93 0x25a0, 0x00a0 };
94
95 SimpleEncodingHolder cp437 = new SimpleEncodingHolder(cp437_high_chars);
96
97 simpleEncodings.put("CP437",cp437);
98 simpleEncodings.put("Cp437",cp437);
99 simpleEncodings.put("cp437",cp437);
100 simpleEncodings.put("IBM437",cp437);
101 simpleEncodings.put("ibm437",cp437);
102
103 char[] cp850_high_chars =
104 new char[] { 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0,
105 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef,
106 0x00ee, 0x00ec, 0x00c4, 0x00c5, 0x00c9, 0x00e6,
107 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9,
108 0x00ff, 0x00d6, 0x00dc, 0x00f8, 0x00a3, 0x00d8,
109 0x00d7, 0x0192, 0x00e1, 0x00ed, 0x00f3, 0x00fa,
110 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x00ae,
111 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
112 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00c1,
113 0x00c2, 0x00c0, 0x00a9, 0x2563, 0x2551, 0x2557,
114 0x255d, 0x00a2, 0x00a5, 0x2510, 0x2514, 0x2534,
115 0x252c, 0x251c, 0x2500, 0x253c, 0x00e3, 0x00c3,
116 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550,
117 0x256c, 0x00a4, 0x00f0, 0x00d0, 0x00ca, 0x00cb,
118 0x00c8, 0x0131, 0x00cd, 0x00ce, 0x00cf, 0x2518,
119 0x250c, 0x2588, 0x2584, 0x00a6, 0x00cc, 0x2580,
120 0x00d3, 0x00df, 0x00d4, 0x00d2, 0x00f5, 0x00d5,
121 0x00b5, 0x00fe, 0x00de, 0x00da, 0x00db, 0x00d9,
122 0x00fd, 0x00dd, 0x00af, 0x00b4, 0x00ad, 0x00b1,
123 0x2017, 0x00be, 0x00b6, 0x00a7, 0x00f7, 0x00b8,
124 0x00b0, 0x00a8, 0x00b7, 0x00b9, 0x00b3, 0x00b2,
125 0x25a0, 0x00a0 };
126
127 SimpleEncodingHolder cp850 = new SimpleEncodingHolder(cp850_high_chars);
128
129 simpleEncodings.put("CP850",cp850);
130 simpleEncodings.put("Cp850",cp850);
131 simpleEncodings.put("cp850",cp850);
132 simpleEncodings.put("IBM850",cp850);
133 simpleEncodings.put("ibm850",cp850);
134 }
135
136 /**
137 * Grow a byte buffer, so it has a minimal capacity or at least
138 * the double capacity of the original buffer
139 *
140 * @param b The original buffer.
141 * @param newCapacity The minimal requested new capacity.
142 * @return A byte buffer <code>r</code> with
143 * <code>r.capacity() = max(b.capacity()*2,newCapacity)</code> and
144 * all the data contained in <code>b</code> copied to the beginning
145 * of <code>r</code>.
146 *
147 */
148 static ByteBuffer growBuffer(ByteBuffer b, int newCapacity) {
149 b.limit(b.position());
150 b.rewind();
151
152 int c2 = b.capacity() * 2;
153 ByteBuffer on = ByteBuffer.allocate(c2 < newCapacity ? newCapacity : c2);
154
155 on.put(b);
156 return on;
157 }
158
159
160 /**
161 * The hexadecimal digits <code>0,...,9,A,...,F</code> encoded as
162 * ASCII bytes.
163 */
164 private static final byte[] HEX_DIGITS =
165 new byte [] {
166 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41,
167 0x42, 0x43, 0x44, 0x45, 0x46
168 };
169
170 /**
171 * Append <code>%Uxxxx</code> to the given byte buffer.
172 * The caller must assure, that <code>bb.remaining()&gt;=6</code>.
173 *
174 * @param bb The byte buffer to write to.
175 * @param c The character to write.
176 */
177 static void appendSurrogate(ByteBuffer bb, char c) {
178
179 bb.put((byte) '%');
180 bb.put((byte) 'U');
181
182 bb.put(HEX_DIGITS[(c >> 12)&0x0f]);
183 bb.put(HEX_DIGITS[(c >> 8)&0x0f]);
184 bb.put(HEX_DIGITS[(c >> 4)&0x0f]);
185 bb.put(HEX_DIGITS[c & 0x0f]);
186 }
187
188
189 /**
190 * name of the encoding UTF-8
191 */
192 static final String UTF8 = "UTF8";
193
194 /**
195 * variant name of the encoding UTF-8 used for comparisions.
196 */
197 private static final String UTF_DASH_8 = "utf-8";
198
199 /**
200 * name of the encoding UTF-8
201 */
202 static final ZipEncoding UTF8_ZIP_ENCODING = new FallbackZipEncoding(UTF8);
203
204 /**
205 * Instantiates a zip encoding.
206 *
207 * @param name The name of the zip encoding. Specify <code>null</code> for
208 * the platform's default encoding.
209 * @return A zip encoding for the given encoding name.
210 */
211 static ZipEncoding getZipEncoding(String name) {
212
213 // fallback encoding is good enough for utf-8.
214 if (isUTF8(name)) {
215 return UTF8_ZIP_ENCODING;
216 }
217
218 if (name == null) {
219 return new FallbackZipEncoding();
220 }
221
222 SimpleEncodingHolder h =
223 (SimpleEncodingHolder) simpleEncodings.get(name);
224
225 if (h!=null) {
226 return h.getEncoding();
227 }
228
229 try {
230
231 Charset cs = Charset.forName(name);
232 return new NioZipEncoding(cs);
233
234 } catch (UnsupportedCharsetException e) {
235 return new FallbackZipEncoding(name);
236 }
237 }
238
239 /**
240 * Whether a given encoding - or the platform's default encoding
241 * if the parameter is null - is UTF-8.
242 */
243 static boolean isUTF8(String encoding) {
244 if (encoding == null) {
245 // check platform's default encoding
246 encoding = System.getProperty("file.encoding");
247 }
248 return UTF8.equalsIgnoreCase(encoding)
249 || UTF_DASH_8.equalsIgnoreCase(encoding);
250 }
251 }