aboutsummaryrefslogtreecommitdiff
path: root/miscutils/hexedit.c
diff options
context:
space:
mode:
Diffstat (limited to 'miscutils/hexedit.c')
-rw-r--r--miscutils/hexedit.c465
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
28struct 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
64static void restore_term(void)
65{
66 tcsetattr_stdin_TCSANOW(&G.orig_termios);
67 printf(POP_ALT_SCR);
68 fflush_all();
69}
70
71static 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
82static 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
127static 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
159static 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 */
181static 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}
208static 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}
232static 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"
260int hexedit_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
261int 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}