diff options
Diffstat (limited to 'miscutils/hexedit.c')
-rw-r--r-- | miscutils/hexedit.c | 465 |
1 files changed, 465 insertions, 0 deletions
diff --git a/miscutils/hexedit.c b/miscutils/hexedit.c new file mode 100644 index 000000000..bafb834b5 --- /dev/null +++ b/miscutils/hexedit.c | |||
@@ -0,0 +1,465 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2017 Denys Vlasenko <vda.linux@googlemail.com> | ||
3 | * | ||
4 | * Licensed under GPLv2, see file LICENSE in this source tree. | ||
5 | */ | ||
6 | //config:config HEXEDIT | ||
7 | //config: bool "hexedit" | ||
8 | //config: default y | ||
9 | //config: help | ||
10 | //config: Edit file in hexadecimal. | ||
11 | |||
12 | //applet:IF_HEXEDIT(APPLET(hexedit, BB_DIR_USR_BIN, BB_SUID_DROP)) | ||
13 | |||
14 | //kbuild:lib-$(CONFIG_HEXEDIT) += hexedit.o | ||
15 | |||
16 | #include "libbb.h" | ||
17 | |||
18 | #define ESC "\033" | ||
19 | #define HOME ESC"[H" | ||
20 | #define CLEAR ESC"[J" | ||
21 | #define CLEAR_TILL_EOL ESC"[K" | ||
22 | #define SET_ALT_SCR ESC"[?1049h" | ||
23 | #define POP_ALT_SCR ESC"[?1049l" | ||
24 | |||
25 | #undef CTRL | ||
26 | #define CTRL(c) ((c) & (uint8_t)~0x60) | ||
27 | |||
28 | struct globals { | ||
29 | smallint half; | ||
30 | smallint in_read_key; | ||
31 | int fd; | ||
32 | unsigned height; | ||
33 | unsigned row; | ||
34 | unsigned pagesize; | ||
35 | uint8_t *baseaddr; | ||
36 | uint8_t *current_byte; | ||
37 | uint8_t *eof_byte; | ||
38 | off_t size; | ||
39 | off_t offset; | ||
40 | /* needs to be zero-inited, thus keeping it in G: */ | ||
41 | char read_key_buffer[KEYCODE_BUFFER_SIZE]; | ||
42 | struct termios orig_termios; | ||
43 | }; | ||
44 | #define G (*ptr_to_globals) | ||
45 | #define INIT_G() do { \ | ||
46 | SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ | ||
47 | } while (0) | ||
48 | |||
49 | //TODO: move to libbb | ||
50 | #if defined(__x86_64__) || defined(i386) | ||
51 | # define G_pagesize 4096 | ||
52 | # define INIT_PAGESIZE() ((void)0) | ||
53 | #else | ||
54 | # define G_pagesize (G.pagesize) | ||
55 | # define INIT_PAGESIZE() ((void)(G.pagesize = getpagesize())) | ||
56 | #endif | ||
57 | |||
58 | /* hopefully there aren't arches with PAGE_SIZE > 64k */ | ||
59 | #define G_mapsize (64*1024) | ||
60 | |||
61 | /* "12ef5670 (xx )*16 _1_3_5_7_9abcdef\n"NUL */ | ||
62 | #define LINEBUF_SIZE (8 + 1 + 3*16 + 16 + 1 + 1 /*paranoia:*/ + 13) | ||
63 | |||
64 | static void restore_term(void) | ||
65 | { | ||
66 | tcsetattr_stdin_TCSANOW(&G.orig_termios); | ||
67 | printf(POP_ALT_SCR); | ||
68 | fflush_all(); | ||
69 | } | ||
70 | |||
71 | static void sig_catcher(int sig) | ||
72 | { | ||
73 | if (!G.in_read_key) { | ||
74 | /* now it's not safe to do I/O, just inform the main loop */ | ||
75 | bb_got_signal = sig; | ||
76 | return; | ||
77 | } | ||
78 | restore_term(); | ||
79 | kill_myself_with_sig(sig); | ||
80 | } | ||
81 | |||
82 | static int format_line(char *hex, uint8_t *data, off_t offset) | ||
83 | { | ||
84 | int ofs_pos; | ||
85 | char *text; | ||
86 | uint8_t *end, *end1; | ||
87 | |||
88 | #if 1 | ||
89 | /* Can be more than 4Gb, thus >8 chars, thus use a variable - don't assume 8! */ | ||
90 | ofs_pos = sprintf(hex, "%08"OFF_FMT"x ", offset); | ||
91 | #else | ||
92 | if (offset <= 0xffff) | ||
93 | ofs_pos = sprintf(hex, "%04"OFF_FMT"x ", offset); | ||
94 | else | ||
95 | ofs_pos = sprintf(hex, "%08"OFF_FMT"x ", offset); | ||
96 | #endif | ||
97 | hex += ofs_pos; | ||
98 | |||
99 | text = hex + 16 * 3; | ||
100 | end1 = data + 15; | ||
101 | if ((G.size - offset) > 0) { | ||
102 | end = end1; | ||
103 | if ((G.size - offset) <= 15) | ||
104 | end = data + (G.size - offset) - 1; | ||
105 | while (data <= end) { | ||
106 | uint8_t c = *data++; | ||
107 | *hex++ = bb_hexdigits_upcase[c >> 4]; | ||
108 | *hex++ = bb_hexdigits_upcase[c & 0xf]; | ||
109 | *hex++ = ' '; | ||
110 | if (c < ' ' || c > 0x7e) | ||
111 | c = '.'; | ||
112 | *text++ = c; | ||
113 | } | ||
114 | } | ||
115 | while (data <= end1) { | ||
116 | *hex++ = ' '; | ||
117 | *hex++ = ' '; | ||
118 | *hex++ = ' '; | ||
119 | *text++ = ' '; | ||
120 | data++; | ||
121 | } | ||
122 | *text = '\0'; | ||
123 | |||
124 | return ofs_pos; | ||
125 | } | ||
126 | |||
127 | static void redraw(unsigned cursor) | ||
128 | { | ||
129 | uint8_t *data; | ||
130 | off_t offset; | ||
131 | unsigned i, pos; | ||
132 | |||
133 | printf(HOME CLEAR); | ||
134 | |||
135 | /* if cursor is past end of screen, how many lines to move down? */ | ||
136 | i = (cursor / 16) - G.height + 1; | ||
137 | if ((int)i < 0) | ||
138 | i = 0; | ||
139 | |||
140 | data = G.baseaddr + i * 16; | ||
141 | offset = G.offset + i * 16; | ||
142 | cursor -= i * 16; | ||
143 | pos = i = 0; | ||
144 | while (i < G.height) { | ||
145 | char buf[LINEBUF_SIZE]; | ||
146 | pos = format_line(buf, data, offset); | ||
147 | printf( | ||
148 | "\r\n%s" + (!i) * 2, /* print \r\n only on 2nd line and later */ | ||
149 | buf | ||
150 | ); | ||
151 | data += 16; | ||
152 | offset += 16; | ||
153 | i++; | ||
154 | } | ||
155 | |||
156 | printf(ESC"[%u;%uH", 1 + cursor / 16, 1 + pos + (cursor & 0xf) * 3); | ||
157 | } | ||
158 | |||
159 | static void redraw_cur_line(void) | ||
160 | { | ||
161 | char buf[LINEBUF_SIZE]; | ||
162 | uint8_t *data; | ||
163 | off_t offset; | ||
164 | int column; | ||
165 | |||
166 | column = (0xf & (uintptr_t)G.current_byte); | ||
167 | data = G.current_byte - column; | ||
168 | offset = G.offset + (data - G.baseaddr); | ||
169 | |||
170 | column = column*3 + G.half; | ||
171 | column += format_line(buf, data, offset); | ||
172 | printf("%s" | ||
173 | "\r" | ||
174 | "%.*s", | ||
175 | buf + column, | ||
176 | column, buf | ||
177 | ); | ||
178 | } | ||
179 | |||
180 | /* if remappers return 0, no change was done */ | ||
181 | static int remap(unsigned cur_pos) | ||
182 | { | ||
183 | if (G.baseaddr) | ||
184 | munmap(G.baseaddr, G_mapsize); | ||
185 | |||
186 | G.baseaddr = mmap(NULL, | ||
187 | G_mapsize, | ||
188 | PROT_READ | PROT_WRITE, | ||
189 | MAP_SHARED, | ||
190 | G.fd, | ||
191 | G.offset | ||
192 | ); | ||
193 | if (G.baseaddr == MAP_FAILED) { | ||
194 | restore_term(); | ||
195 | bb_perror_msg_and_die("mmap"); | ||
196 | } | ||
197 | |||
198 | G.current_byte = G.baseaddr + cur_pos; | ||
199 | |||
200 | G.eof_byte = G.baseaddr + G_mapsize; | ||
201 | if ((G.size - G.offset) < G_mapsize) { | ||
202 | /* mapping covers tail of the file */ | ||
203 | /* we do have a mapped byte which is past eof */ | ||
204 | G.eof_byte = G.baseaddr + (G.size - G.offset); | ||
205 | } | ||
206 | return 1; | ||
207 | } | ||
208 | static int move_mapping_further(void) | ||
209 | { | ||
210 | unsigned pos; | ||
211 | unsigned pagesize; | ||
212 | |||
213 | if ((G.size - G.offset) < G_mapsize) | ||
214 | return 0; /* can't move mapping even further, it's at the end already */ | ||
215 | |||
216 | pagesize = G_pagesize; /* constant on most arches */ | ||
217 | pos = G.current_byte - G.baseaddr; | ||
218 | if (pos >= pagesize) { | ||
219 | /* move offset up until current position is in 1st page */ | ||
220 | do { | ||
221 | G.offset += pagesize; | ||
222 | if (G.offset == 0) { /* whoops */ | ||
223 | G.offset -= pagesize; | ||
224 | break; | ||
225 | } | ||
226 | pos -= pagesize; | ||
227 | } while (pos >= pagesize); | ||
228 | return remap(pos); | ||
229 | } | ||
230 | return 0; | ||
231 | } | ||
232 | static int move_mapping_lower(void) | ||
233 | { | ||
234 | unsigned pos; | ||
235 | unsigned pagesize; | ||
236 | |||
237 | if (G.offset == 0) | ||
238 | return 0; /* we are at 0 already */ | ||
239 | |||
240 | pagesize = G_pagesize; /* constant on most arches */ | ||
241 | pos = G.current_byte - G.baseaddr; | ||
242 | |||
243 | /* move offset down until current position is in last page */ | ||
244 | pos += pagesize; | ||
245 | while (pos < G_mapsize) { | ||
246 | pos += pagesize; | ||
247 | G.offset -= pagesize; | ||
248 | if (G.offset == 0) | ||
249 | break; | ||
250 | } | ||
251 | pos -= pagesize; | ||
252 | |||
253 | return remap(pos); | ||
254 | } | ||
255 | |||
256 | //usage:#define hexedit_trivial_usage | ||
257 | //usage: "FILE" | ||
258 | //usage:#define hexedit_full_usage "\n\n" | ||
259 | //usage: "Edit FILE in hexadecimal" | ||
260 | int hexedit_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; | ||
261 | int hexedit_main(int argc UNUSED_PARAM, char **argv) | ||
262 | { | ||
263 | INIT_G(); | ||
264 | INIT_PAGESIZE(); | ||
265 | |||
266 | get_terminal_width_height(-1, NULL, &G.height); | ||
267 | if (1) { | ||
268 | /* reduce number of write() syscalls while PgUp/Down: fully buffered output */ | ||
269 | unsigned sz = (G.height | 0xf) * LINEBUF_SIZE; | ||
270 | setvbuf(stdout, xmalloc(sz), _IOFBF, sz); | ||
271 | } | ||
272 | |||
273 | getopt32(argv, "^" "" "\0" "=1"/*one arg*/); | ||
274 | argv += optind; | ||
275 | |||
276 | G.fd = xopen(*argv, O_RDWR); | ||
277 | G.size = xlseek(G.fd, 0, SEEK_END); | ||
278 | |||
279 | /* TERMIOS_RAW_CRNL suppresses \n -> \r\n translation, helps with down-arrow */ | ||
280 | printf(SET_ALT_SCR); | ||
281 | set_termios_to_raw(STDIN_FILENO, &G.orig_termios, TERMIOS_RAW_CRNL); | ||
282 | bb_signals(BB_FATAL_SIGS, sig_catcher); | ||
283 | |||
284 | remap(0); | ||
285 | redraw(0); | ||
286 | |||
287 | //TODO: //Home/End: start/end of line; '<'/'>': start/end of file | ||
288 | //Backspace: undo | ||
289 | //Ctrl-L: redraw | ||
290 | //Ctrl-Z: suspend | ||
291 | //'/', Ctrl-S: search | ||
292 | //TODO: detect window resize | ||
293 | |||
294 | for (;;) { | ||
295 | unsigned cnt; | ||
296 | int32_t key = key; /* for compiler */ | ||
297 | uint8_t byte; | ||
298 | |||
299 | fflush_all(); | ||
300 | G.in_read_key = 1; | ||
301 | if (!bb_got_signal) | ||
302 | key = read_key(STDIN_FILENO, G.read_key_buffer, -1); | ||
303 | G.in_read_key = 0; | ||
304 | if (bb_got_signal) | ||
305 | key = CTRL('X'); | ||
306 | |||
307 | cnt = 1; | ||
308 | if ((unsigned)(key - 'A') <= 'Z' - 'A') | ||
309 | key |= 0x20; /* convert A-Z to a-z */ | ||
310 | switch (key) { | ||
311 | case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': | ||
312 | /* convert to '0'+10...15 */ | ||
313 | key = key - ('a' - '0' - 10); | ||
314 | /* fall through */ | ||
315 | case '0': case '1': case '2': case '3': case '4': | ||
316 | case '5': case '6': case '7': case '8': case '9': | ||
317 | if (G.current_byte == G.eof_byte) { | ||
318 | if (!move_mapping_further()) { | ||
319 | /* already at EOF; extend the file */ | ||
320 | if (++G.size <= 0 /* overflow? */ | ||
321 | || ftruncate(G.fd, G.size) != 0 /* error extending? (e.g. block dev) */ | ||
322 | ) { | ||
323 | G.size--; | ||
324 | break; | ||
325 | } | ||
326 | G.eof_byte++; | ||
327 | } | ||
328 | } | ||
329 | key -= '0'; | ||
330 | byte = *G.current_byte & 0xf0; | ||
331 | if (!G.half) { | ||
332 | byte = *G.current_byte & 0x0f; | ||
333 | key <<= 4; | ||
334 | } | ||
335 | *G.current_byte = byte + key; | ||
336 | /* can't just print one updated hex char: need to update right-hand ASCII too */ | ||
337 | redraw_cur_line(); | ||
338 | /* fall through */ | ||
339 | case KEYCODE_RIGHT: | ||
340 | if (G.current_byte == G.eof_byte) | ||
341 | break; /* eof - don't allow going past it */ | ||
342 | byte = *G.current_byte; | ||
343 | if (!G.half) { | ||
344 | G.half = 1; | ||
345 | putchar(bb_hexdigits_upcase[byte >> 4]); | ||
346 | } else { | ||
347 | G.half = 0; | ||
348 | G.current_byte++; | ||
349 | if ((0xf & (uintptr_t)G.current_byte) == 0) { | ||
350 | /* rightmost pos, wrap to next line */ | ||
351 | if (G.current_byte == G.eof_byte) | ||
352 | move_mapping_further(); | ||
353 | printf(ESC"[46D"); /* cursor left 3*15 + 1 chars */ | ||
354 | goto down; | ||
355 | } | ||
356 | putchar(bb_hexdigits_upcase[byte & 0xf]); | ||
357 | putchar(' '); | ||
358 | } | ||
359 | break; | ||
360 | case KEYCODE_PAGEDOWN: | ||
361 | cnt = G.height; | ||
362 | case KEYCODE_DOWN: | ||
363 | k_down: | ||
364 | G.current_byte += 16; | ||
365 | if (G.current_byte >= G.eof_byte) { | ||
366 | move_mapping_further(); | ||
367 | if (G.current_byte > G.eof_byte) { | ||
368 | /* _after_ eof - don't allow this */ | ||
369 | G.current_byte -= 16; | ||
370 | break; | ||
371 | } | ||
372 | } | ||
373 | down: | ||
374 | putchar('\n'); /* down one line, possibly scroll screen */ | ||
375 | G.row++; | ||
376 | if (G.row >= G.height) { | ||
377 | G.row--; | ||
378 | redraw_cur_line(); | ||
379 | } | ||
380 | if (--cnt) | ||
381 | goto k_down; | ||
382 | break; | ||
383 | |||
384 | case KEYCODE_LEFT: | ||
385 | if (G.half) { | ||
386 | G.half = 0; | ||
387 | printf(ESC"[D"); | ||
388 | break; | ||
389 | } | ||
390 | if ((0xf & (uintptr_t)G.current_byte) == 0) { | ||
391 | /* leftmost pos, wrap to prev line */ | ||
392 | if (G.current_byte == G.baseaddr) { | ||
393 | if (!move_mapping_lower()) | ||
394 | break; /* first line, don't do anything */ | ||
395 | } | ||
396 | G.half = 1; | ||
397 | G.current_byte--; | ||
398 | printf(ESC"[46C"); /* cursor right 3*15 + 1 chars */ | ||
399 | goto up; | ||
400 | } | ||
401 | G.half = 1; | ||
402 | G.current_byte--; | ||
403 | printf(ESC"[2D"); | ||
404 | break; | ||
405 | case KEYCODE_PAGEUP: | ||
406 | cnt = G.height; | ||
407 | case KEYCODE_UP: | ||
408 | k_up: | ||
409 | if ((G.current_byte - G.baseaddr) < 16) { | ||
410 | if (!move_mapping_lower()) | ||
411 | break; /* already at 0, stop */ | ||
412 | } | ||
413 | G.current_byte -= 16; | ||
414 | up: | ||
415 | if (G.row != 0) { | ||
416 | G.row--; | ||
417 | printf(ESC"[A"); /* up (won't scroll) */ | ||
418 | } else { | ||
419 | //printf(ESC"[T"); /* scroll up */ - not implemented on Linux VT! | ||
420 | printf(ESC"M"); /* scroll up */ | ||
421 | redraw_cur_line(); | ||
422 | } | ||
423 | if (--cnt) | ||
424 | goto k_up; | ||
425 | break; | ||
426 | |||
427 | case '\n': | ||
428 | case '\r': | ||
429 | /* [Enter]: goto specified position */ | ||
430 | { | ||
431 | char buf[sizeof(G.offset)*3 + 4]; | ||
432 | printf(ESC"[999;1H" CLEAR_TILL_EOL); /* go to last line */ | ||
433 | if (read_line_input(NULL, "Go to (dec,0Xhex,0oct): ", buf, sizeof(buf)) > 0) { | ||
434 | off_t t; | ||
435 | unsigned cursor; | ||
436 | |||
437 | t = bb_strtoull(buf, NULL, 0); | ||
438 | if (t >= G.size) | ||
439 | t = G.size - 1; | ||
440 | cursor = t & (G_pagesize - 1); | ||
441 | t -= cursor; | ||
442 | if (t < 0) | ||
443 | cursor = t = 0; | ||
444 | if (t != 0 && cursor < 0x1ff) { | ||
445 | /* very close to end of page, possibly to EOF */ | ||
446 | /* move one page lower */ | ||
447 | t -= G_pagesize; | ||
448 | cursor += G_pagesize; | ||
449 | } | ||
450 | G.offset = t; | ||
451 | remap(cursor); | ||
452 | redraw(cursor); | ||
453 | break; | ||
454 | } | ||
455 | /* ^C/EOF/error: fall through to exiting */ | ||
456 | } | ||
457 | case CTRL('X'): | ||
458 | restore_term(); | ||
459 | return EXIT_SUCCESS; | ||
460 | } /* switch */ | ||
461 | } /* for (;;) */ | ||
462 | |||
463 | /* not reached */ | ||
464 | return EXIT_SUCCESS; | ||
465 | } | ||