1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * lib/hexdump.c
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation. See README and COPYING for
8 * more details.
9 */
10
11 #include <common.h>
12 #include <hexdump.h>
13 #include <linux/ctype.h>
14 #include <linux/compat.h>
15 #include <linux/log2.h>
16 #include <asm/unaligned.h>
17
18 const char hex_asc[] = "0123456789abcdef";
19 const char hex_asc_upper[] = "0123456789ABCDEF";
20
21 #ifdef CONFIG_HEXDUMP
22 /**
23 * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
24 * @buf: data blob to dump
25 * @len: number of bytes in the @buf
26 * @rowsize: number of bytes to print per line; must be 16 or 32
27 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
28 * @linebuf: where to put the converted data
29 * @linebuflen: total size of @linebuf, including space for terminating NUL
30 * @ascii: include ASCII after the hex output
31 *
32 * hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
33 * 16 or 32 bytes of input data converted to hex + ASCII output.
34 *
35 * Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
36 * to a hex + ASCII dump at the supplied memory location.
37 * The converted output is always NUL-terminated.
38 *
39 * E.g.:
40 * hex_dump_to_buffer(frame->data, frame->len, 16, 1,
41 * linebuf, sizeof(linebuf), true);
42 *
43 * example output buffer:
44 * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
45 *
46 * Return:
47 * The amount of bytes placed in the buffer without terminating NUL. If the
48 * output was truncated, then the return value is the number of bytes
49 * (excluding the terminating NUL) which would have been written to the final
50 * string if enough space had been available.
51 */
hex_dump_to_buffer(const void * buf,size_t len,int rowsize,int groupsize,char * linebuf,size_t linebuflen,bool ascii)52 int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize,
53 char *linebuf, size_t linebuflen, bool ascii)
54 {
55 const u8 *ptr = buf;
56 int ngroups;
57 u8 ch;
58 int j, lx = 0;
59 int ascii_column;
60 int ret;
61
62 if (rowsize != 16 && rowsize != 32)
63 rowsize = 16;
64
65 if (len > rowsize) /* limit to one line at a time */
66 len = rowsize;
67 if (!is_power_of_2(groupsize) || groupsize > 8)
68 groupsize = 1;
69 if ((len % groupsize) != 0) /* no mixed size output */
70 groupsize = 1;
71
72 ngroups = len / groupsize;
73 ascii_column = rowsize * 2 + rowsize / groupsize + 1;
74
75 if (!linebuflen)
76 goto overflow1;
77
78 if (!len)
79 goto nil;
80
81 if (groupsize == 8) {
82 const u64 *ptr8 = buf;
83
84 for (j = 0; j < ngroups; j++) {
85 ret = snprintf(linebuf + lx, linebuflen - lx,
86 "%s%16.16llx", j ? " " : "",
87 get_unaligned(ptr8 + j));
88 if (ret >= linebuflen - lx)
89 goto overflow1;
90 lx += ret;
91 }
92 } else if (groupsize == 4) {
93 const u32 *ptr4 = buf;
94
95 for (j = 0; j < ngroups; j++) {
96 ret = snprintf(linebuf + lx, linebuflen - lx,
97 "%s%8.8x", j ? " " : "",
98 get_unaligned(ptr4 + j));
99 if (ret >= linebuflen - lx)
100 goto overflow1;
101 lx += ret;
102 }
103 } else if (groupsize == 2) {
104 const u16 *ptr2 = buf;
105
106 for (j = 0; j < ngroups; j++) {
107 ret = snprintf(linebuf + lx, linebuflen - lx,
108 "%s%4.4x", j ? " " : "",
109 get_unaligned(ptr2 + j));
110 if (ret >= linebuflen - lx)
111 goto overflow1;
112 lx += ret;
113 }
114 } else {
115 for (j = 0; j < len; j++) {
116 if (linebuflen < lx + 2)
117 goto overflow2;
118 ch = ptr[j];
119 linebuf[lx++] = hex_asc_hi(ch);
120 if (linebuflen < lx + 2)
121 goto overflow2;
122 linebuf[lx++] = hex_asc_lo(ch);
123 if (linebuflen < lx + 2)
124 goto overflow2;
125 linebuf[lx++] = ' ';
126 }
127 if (j)
128 lx--;
129 }
130 if (!ascii)
131 goto nil;
132
133 while (lx < ascii_column) {
134 if (linebuflen < lx + 2)
135 goto overflow2;
136 linebuf[lx++] = ' ';
137 }
138 for (j = 0; j < len; j++) {
139 if (linebuflen < lx + 2)
140 goto overflow2;
141 ch = ptr[j];
142 linebuf[lx++] = (isascii(ch) && isprint(ch)) ? ch : '.';
143 }
144 nil:
145 linebuf[lx] = '\0';
146 return lx;
147 overflow2:
148 linebuf[lx++] = '\0';
149 overflow1:
150 return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1;
151 }
152
153 /**
154 * print_hex_dump - print a text hex dump to syslog for a binary blob of data
155 * @prefix_str: string to prefix each line with;
156 * caller supplies trailing spaces for alignment if desired
157 * @prefix_type: controls whether prefix of an offset, address, or none
158 * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
159 * @rowsize: number of bytes to print per line; must be 16 or 32
160 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
161 * @buf: data blob to dump
162 * @len: number of bytes in the @buf
163 * @ascii: include ASCII after the hex output
164 *
165 * Given a buffer of u8 data, print_hex_dump() prints a hex + ASCII dump
166 * to the stdio, with an optional leading prefix.
167 *
168 * print_hex_dump() works on one "line" of output at a time, i.e.,
169 * 16 or 32 bytes of input data converted to hex + ASCII output.
170 * print_hex_dump() iterates over the entire input @buf, breaking it into
171 * "line size" chunks to format and print.
172 *
173 * E.g.:
174 * print_hex_dump("raw data: ", DUMP_PREFIX_ADDRESS, 16, 1, frame->data,
175 * frame->len, true);
176 *
177 * Example output using %DUMP_PREFIX_OFFSET and 1-byte mode:
178 * 0009ab42: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
179 * Example output using %DUMP_PREFIX_ADDRESS and 4-byte mode:
180 * ffffffff88089af0: 73727170 77767574 7b7a7978 7f7e7d7c pqrstuvwxyz{|}~.
181 */
print_hex_dump(const char * prefix_str,int prefix_type,int rowsize,int groupsize,const void * buf,size_t len,bool ascii)182 void print_hex_dump(const char *prefix_str, int prefix_type, int rowsize,
183 int groupsize, const void *buf, size_t len, bool ascii)
184 {
185 const u8 *ptr = buf;
186 int i, linelen, remaining = len;
187 char linebuf[32 * 3 + 2 + 32 + 1];
188
189 if (rowsize != 16 && rowsize != 32)
190 rowsize = 16;
191
192 for (i = 0; i < len; i += rowsize) {
193 linelen = min(remaining, rowsize);
194 remaining -= rowsize;
195
196 hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
197 linebuf, sizeof(linebuf), ascii);
198
199 switch (prefix_type) {
200 case DUMP_PREFIX_ADDRESS:
201 printf("%s%p: %s\n", prefix_str, ptr + i, linebuf);
202 break;
203 case DUMP_PREFIX_OFFSET:
204 printf("%s%.8x: %s\n", prefix_str, i, linebuf);
205 break;
206 default:
207 printf("%s%s\n", prefix_str, linebuf);
208 break;
209 }
210 }
211 }
212
213 /**
214 * print_hex_dump_bytes - shorthand form of print_hex_dump() with default params
215 * @prefix_str: string to prefix each line with;
216 * caller supplies trailing spaces for alignment if desired
217 * @prefix_type: controls whether prefix of an offset, address, or none
218 * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
219 * @buf: data blob to dump
220 * @len: number of bytes in the @buf
221 *
222 * Calls print_hex_dump(), rowsize of 16, groupsize of 1,
223 * and ASCII output included.
224 */
print_hex_dump_bytes(const char * prefix_str,int prefix_type,const void * buf,size_t len)225 void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
226 const void *buf, size_t len)
227 {
228 print_hex_dump(prefix_str, prefix_type, 16, 1, buf, len, true);
229 }
230 #else
231 /*
232 * Some code in U-Boot copy-pasted from Linux kernel uses both
233 * functions below so to keep stuff compilable we keep these stubs here.
234 */
print_hex_dump(const char * prefix_str,int prefix_type,int rowsize,int groupsize,const void * buf,size_t len,bool ascii)235 void print_hex_dump(const char *prefix_str, int prefix_type,
236 int rowsize, int groupsize, const void *buf,
237 size_t len, bool ascii)
238 {
239 }
240
print_hex_dump_bytes(const char * prefix_str,int prefix_type,const void * buf,size_t len)241 void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
242 const void *buf, size_t len)
243 {
244 }
245 #endif /* CONFIG_HEXDUMP */
246