1 /*
2 * Copyright (c) 1995, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26
27 package sun.security.util;
28
29 import java.io.ByteArrayInputStream;
30 import java.io.ByteArrayOutputStream;
31 import java.io.InputStream;
32 import java.io.PrintStream;
33 import java.io.OutputStream;
34 import java.io.IOException;
35 import java.nio.ByteBuffer;
36
37 /**
38 * This class encodes a buffer into the classic: "Hexadecimal Dump" format of
39 * the past. It is useful for analyzing the contents of binary buffers.
40 * The format produced is as follows:
41 * <pre>
42 * xxxx: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ................
43 * </pre>
44 * Where xxxx is the offset into the buffer in 16 byte chunks, followed
45 * by ascii coded hexadecimal bytes followed by the ASCII representation of
46 * the bytes or '.' if they are not valid bytes.
47 *
48 * @author Chuck McManis
49 */
50
51 public class HexDumpEncoder {
52
53 private int offset;
54 private int thisLineLength;
55 private int currentByte;
56 private byte[] thisLine = new byte[16];
57
58 static void hexDigit(PrintStream p, byte x) {
59 char c;
60
61 c = (char) ((x >> 4) & 0xf);
62 if (c > 9)
63 c = (char) ((c-10) + 'A');
64 else
65 c = (char)(c + '0');
66 p.write(c);
67 c = (char) (x & 0xf);
68 if (c > 9)
69 c = (char)((c-10) + 'A');
70 else
71 c = (char)(c + '0');
72 p.write(c);
73 }
74
75 protected int bytesPerAtom() {
76 return (1);
77 }
78
79 protected int bytesPerLine() {
80 return (16);
81 }
82
83 protected void encodeBufferPrefix(OutputStream o) throws IOException {
84 offset = 0;
85 pStream = new PrintStream(o);
86 }
87
88 protected void encodeLinePrefix(OutputStream o, int len) throws IOException {
89 hexDigit(pStream, (byte)((offset >>> 8) & 0xff));
90 hexDigit(pStream, (byte)(offset & 0xff));
91 pStream.print(": ");
92 currentByte = 0;
93 thisLineLength = len;
94 }
95
96 protected void encodeAtom(OutputStream o, byte[] buf, int off, int len) throws IOException {
97 thisLine[currentByte] = buf[off];
98 hexDigit(pStream, buf[off]);
99 pStream.print(" ");
100 currentByte++;
101 if (currentByte == 8)
102 pStream.print(" ");
103 }
104
105 protected void encodeLineSuffix(OutputStream o) throws IOException {
106 if (thisLineLength < 16) {
107 for (int i = thisLineLength; i < 16; i++) {
108 pStream.print(" ");
109 if (i == 7)
110 pStream.print(" ");
111 }
112 }
113 pStream.print(" ");
114 for (int i = 0; i < thisLineLength; i++) {
115 if ((thisLine[i] < ' ') || (thisLine[i] > 'z')) {
116 pStream.print(".");
117 } else {
118 pStream.write(thisLine[i]);
119 }
120 }
121 pStream.println();
122 offset += thisLineLength;
123 }
124
125 /** Stream that understands "printing" */
126 protected PrintStream pStream;
127
128 /**
129 * This method works around the bizarre semantics of BufferedInputStream's
130 * read method.
131 */
132 protected int readFully(InputStream in, byte[] buffer)
133 throws java.io.IOException {
134 for (int i = 0; i < buffer.length; i++) {
135 int q = in.read();
136 if (q == -1)
137 return i;
138 buffer[i] = (byte)q;
139 }
140 return buffer.length;
141 }
142
143 /**
144 * Encode bytes from the input stream, and write them as text characters
145 * to the output stream. This method will run until it exhausts the
146 * input stream, but does not print the line suffix for a final
147 * line that is shorter than bytesPerLine().
148 */
149 public void encode(InputStream inStream, OutputStream outStream)
150 throws IOException
151 {
152 int j;
153 int numBytes;
154 byte[] tmpbuffer = new byte[bytesPerLine()];
155
156 encodeBufferPrefix(outStream);
157
158 while (true) {
159 numBytes = readFully(inStream, tmpbuffer);
160 if (numBytes == 0) {
161 break;
162 }
163 encodeLinePrefix(outStream, numBytes);
164 for (j = 0; j < numBytes; j += bytesPerAtom()) {
165
166 if ((j + bytesPerAtom()) <= numBytes) {
167 encodeAtom(outStream, tmpbuffer, j, bytesPerAtom());
168 } else {
169 encodeAtom(outStream, tmpbuffer, j, (numBytes)- j);
170 }
171 }
172 if (numBytes < bytesPerLine()) {
173 break;
174 } else {
175 encodeLineSuffix(outStream);
176 }
177 }
178 }
179
180 /**
181 * A 'streamless' version of encode that simply takes a buffer of
182 * bytes and returns a string containing the encoded buffer.
183 */
184 public String encode(byte[] aBuffer) {
185 ByteArrayOutputStream outStream = new ByteArrayOutputStream();
186 ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
187 String retVal = null;
188 try {
189 encode(inStream, outStream);
190 // explicit ascii->unicode conversion
191 retVal = outStream.toString("ISO-8859-1");
192 } catch (Exception IOException) {
193 // This should never happen.
194 throw new Error("CharacterEncoder.encode internal error");
195 }
196 return (retVal);
197 }
198
199 /**
200 * Return a byte array from the remaining bytes in this ByteBuffer.
201 * <P>
202 * The ByteBuffer's position will be advanced to ByteBuffer's limit.
203 * <P>
204 * To avoid an extra copy, the implementation will attempt to return the
205 * byte array backing the ByteBuffer. If this is not possible, a
206 * new byte array will be created.
207 */
208 private byte [] getBytes(ByteBuffer bb) {
209 /*
210 * This should never return a BufferOverflowException, as we're
211 * careful to allocate just the right amount.
212 */
213 byte [] buf = null;
214
215 /*
216 * If it has a usable backing byte buffer, use it. Use only
217 * if the array exactly represents the current ByteBuffer.
218 */
219 if (bb.hasArray()) {
220 byte [] tmp = bb.array();
221 if ((tmp.length == bb.capacity()) &&
222 (tmp.length == bb.remaining())) {
223 buf = tmp;
224 bb.position(bb.limit());
225 }
226 }
227
228 if (buf == null) {
229 /*
230 * This class doesn't have a concept of encode(buf, len, off),
231 * so if we have a partial buffer, we must reallocate
232 * space.
233 */
234 buf = new byte[bb.remaining()];
235
236 /*
237 * position() automatically updated
238 */
239 bb.get(buf);
240 }
241
242 return buf;
243 }
244
245 /**
246 * A 'streamless' version of encode that simply takes a ByteBuffer
247 * and returns a string containing the encoded buffer.
248 * <P>
249 * The ByteBuffer's position will be advanced to ByteBuffer's limit.
250 */
251 public String encode(ByteBuffer aBuffer) {
252 byte [] buf = getBytes(aBuffer);
253 return encode(buf);
254 }
255
256 /**
257 * Encode bytes from the input stream, and write them as text characters
258 * to the output stream. This method will run until it exhausts the
259 * input stream. It differs from encode in that it will add the
260 * line at the end of a final line that is shorter than bytesPerLine().
261 */
262 public void encodeBuffer(InputStream inStream, OutputStream outStream)
263 throws IOException
264 {
265 int j;
266 int numBytes;
267 byte[] tmpbuffer = new byte[bytesPerLine()];
268
269 encodeBufferPrefix(outStream);
270
271 while (true) {
272 numBytes = readFully(inStream, tmpbuffer);
273 if (numBytes == 0) {
274 break;
275 }
276 encodeLinePrefix(outStream, numBytes);
277 for (j = 0; j < numBytes; j += bytesPerAtom()) {
278 if ((j + bytesPerAtom()) <= numBytes) {
279 encodeAtom(outStream, tmpbuffer, j, bytesPerAtom());
280 } else {
281 encodeAtom(outStream, tmpbuffer, j, (numBytes)- j);
282 }
283 }
284 encodeLineSuffix(outStream);
285 if (numBytes < bytesPerLine()) {
286 break;
287 }
288 }
289 }
290
291 /**
292 * Encode the buffer in <i>aBuffer</i> and write the encoded
293 * result to the OutputStream <i>aStream</i>.
294 */
295 public void encodeBuffer(byte[] aBuffer, OutputStream aStream)
296 throws IOException
297 {
298 ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
299 encodeBuffer(inStream, aStream);
300 }
301
302 /**
303 * A 'streamless' version of encode that simply takes a buffer of
304 * bytes and returns a string containing the encoded buffer.
305 */
306 public String encodeBuffer(byte[] aBuffer) {
307 ByteArrayOutputStream outStream = new ByteArrayOutputStream();
308 ByteArrayInputStream inStream = new ByteArrayInputStream(aBuffer);
309 try {
310 encodeBuffer(inStream, outStream);
311 } catch (Exception IOException) {
312 // This should never happen.
313 throw new Error("CharacterEncoder.encodeBuffer internal error");
314 }
315 return (outStream.toString());
316 }
317
318 /**
319 * Encode the <i>aBuffer</i> ByteBuffer and write the encoded
320 * result to the OutputStream <i>aStream</i>.
321 * <P>
322 * The ByteBuffer's position will be advanced to ByteBuffer's limit.
323 */
324 public void encodeBuffer(ByteBuffer aBuffer, OutputStream aStream)
325 throws IOException
326 {
327 byte [] buf = getBytes(aBuffer);
328 encodeBuffer(buf, aStream);
329 }
330
331 }