From 4aca87515a5083ae0e31ce3177189fd43b6d05ac Mon Sep 17 00:00:00 2001 From: Andreas Baumann Date: Sat, 3 Jan 2015 13:58:15 +0100 Subject: patch to Vanilla Tomato 1.28 --- .../src/router/busybox/console-tools/loadfont.c | 406 +++++++++++++++------ 1 file changed, 285 insertions(+), 121 deletions(-) (limited to 'release/src/router/busybox/console-tools/loadfont.c') diff --git a/release/src/router/busybox/console-tools/loadfont.c b/release/src/router/busybox/console-tools/loadfont.c index 6108151a..33641806 100644 --- a/release/src/router/busybox/console-tools/loadfont.c +++ b/release/src/router/busybox/console-tools/loadfont.c @@ -6,68 +6,87 @@ * * Loads the console font, and possibly the corresponding screen map(s). * (Adapted for busybox by Matej Vela.) + * + * Licensed under GPLv2, see file LICENSE in this tarball for details. */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "libbb.h" #include -#include -#include "busybox.h" - -static const int PSF_MAGIC1 = 0x36; -static const int PSF_MAGIC2 = 0x04; - -static const int PSF_MODE512 = 0x01; -static const int PSF_MODEHASTAB = 0x02; -static const int PSF_MAXMODE = 0x03; -static const int PSF_SEPARATOR = 0xFFFF; -struct psf_header { - unsigned char magic1, magic2; /* Magic number */ - unsigned char mode; /* PSF font mode */ - unsigned char charsize; /* Character size */ +#ifndef KDFONTOP +#define KDFONTOP 0x4B72 +struct console_font_op { + unsigned op; /* KD_FONT_OP_* */ + unsigned flags; /* KD_FONT_FLAG_* */ + unsigned width, height; + unsigned charcount; + unsigned char *data; /* font data with height fixed to 32 */ }; -#define PSF_MAGIC_OK(x) ((x).magic1 == PSF_MAGIC1 && (x).magic2 == PSF_MAGIC2) +#define KD_FONT_OP_SET 0 /* Set font */ +#define KD_FONT_OP_GET 1 /* Get font */ +#define KD_FONT_OP_SET_DEFAULT 2 /* Set font to default, + data points to name / NULL */ +#define KD_FONT_OP_COPY 3 /* Copy from another console */ -static void loadnewfont(int fd); +#define KD_FONT_FLAG_OLD 0x80000000 /* Invoked via old interface */ +#define KD_FONT_FLAG_DONT_RECALC 1 /* Don't call adjust_height() */ + /* (Used internally for PIO_FONT support) */ +#endif /* KDFONTOP */ -extern int loadfont_main(int argc, char **argv) -{ - int fd; - if (argc != 1) - bb_show_usage(); +enum { + PSF_MAGIC1 = 0x36, + PSF_MAGIC2 = 0x04, - fd = open(CURRENT_VC, O_RDWR); - if (fd < 0) - bb_perror_msg_and_die("Error opening " CURRENT_VC); - loadnewfont(fd); + PSF_MODE512 = 0x01, + PSF_MODEHASTAB = 0x02, + PSF_MAXMODE = 0x03, + PSF_SEPARATOR = 0xffff +}; - return EXIT_SUCCESS; -} +struct psf_header { + unsigned char magic1, magic2; /* Magic number */ + unsigned char mode; /* PSF font mode */ + unsigned char charsize; /* Character size */ +}; + +#define PSF_MAGIC_OK(x) ((x)->magic1 == PSF_MAGIC1 && (x)->magic2 == PSF_MAGIC2) -static void do_loadfont(int fd, char *inbuf, int unit, int fontsize) +static void do_loadfont(int fd, unsigned char *inbuf, int unit, int fontsize) { - char buf[16384]; + char *buf; int i; - memset(buf, 0, sizeof(buf)); - if (unit < 1 || unit > 32) - bb_error_msg_and_die("Bad character size %d", unit); + bb_error_msg_and_die("bad character size %d", unit); + buf = xzalloc(16 * 1024); for (i = 0; i < fontsize; i++) memcpy(buf + (32 * i), inbuf + (unit * i), unit); -#if defined( PIO_FONTX ) && !defined( __sparc__ ) + { /* KDFONTOP */ + struct console_font_op cfo; + + cfo.op = KD_FONT_OP_SET; + cfo.flags = 0; + cfo.width = 8; + cfo.height = unit; + cfo.charcount = fontsize; + cfo.data = (void*)buf; +#if 0 + if (!ioctl_or_perror(fd, KDFONTOP, &cfo, "KDFONTOP ioctl failed (will try PIO_FONTX)")) + goto ret; /* success */ +#else + xioctl(fd, KDFONTOP, &cfo); +#endif + } + +#if 0 +/* These ones do not honour -C tty (they set font on current tty regardless) + * On x86, this distinction is visible on framebuffer consoles + * (regular character consoles may have only one shared font anyway) + */ +#if defined(PIO_FONTX) && !defined(__sparc__) { struct consolefontdesc cfd; @@ -75,31 +94,31 @@ static void do_loadfont(int fd, char *inbuf, int unit, int fontsize) cfd.charheight = unit; cfd.chardata = buf; - if (ioctl(fd, PIO_FONTX, &cfd) == 0) - return; /* success */ - bb_perror_msg("PIO_FONTX ioctl error (trying PIO_FONT)"); + if (!ioctl_or_perror(fd, PIO_FONTX, &cfd, "PIO_FONTX ioctl failed (will try PIO_FONT)")) + goto ret; /* success */ } #endif - if (ioctl(fd, PIO_FONT, buf)) - bb_perror_msg_and_die("PIO_FONT ioctl error"); + xioctl(fd, PIO_FONT, buf); + ret: +#endif /* 0 */ + free(buf); } -static void -do_loadtable(int fd, unsigned char *inbuf, int tailsz, int fontsize) +static void do_loadtable(int fd, unsigned char *inbuf, int tailsz, int fontsize) { struct unimapinit advice; struct unimapdesc ud; struct unipair *up; int ct = 0, maxct; int glyph; - u_short unicode; + uint16_t unicode; - maxct = tailsz; /* more than enough */ - up = (struct unipair *) xmalloc(maxct * sizeof(struct unipair)); + maxct = tailsz; /* more than enough */ + up = xmalloc(maxct * sizeof(struct unipair)); for (glyph = 0; glyph < fontsize; glyph++) { while (tailsz >= 2) { - unicode = (((u_short) inbuf[1]) << 8) + inbuf[0]; + unicode = (((uint16_t) inbuf[1]) << 8) + inbuf[0]; tailsz -= 2; inbuf += 2; if (unicode == PSF_SEPARATOR) @@ -116,94 +135,239 @@ do_loadtable(int fd, unsigned char *inbuf, int tailsz, int fontsize) advice.advised_hashsize = 0; advice.advised_hashstep = 0; advice.advised_hashlevel = 0; - if (ioctl(fd, PIO_UNIMAPCLR, &advice)) { -#ifdef ENOIOCTLCMD - if (errno == ENOIOCTLCMD) { - bb_error_msg("It seems this kernel is older than 1.1.92"); - bb_error_msg_and_die("No Unicode mapping table loaded."); - } else -#endif - bb_perror_msg_and_die("PIO_UNIMAPCLR"); - } + xioctl(fd, PIO_UNIMAPCLR, &advice); ud.entry_ct = ct; ud.entries = up; - if (ioctl(fd, PIO_UNIMAP, &ud)) { -#if 0 - if (errno == ENOMEM) { - /* change advice parameters */ - } + xioctl(fd, PIO_UNIMAP, &ud); +} + +static void do_load(int fd, struct psf_header *psfhdr, size_t len) +{ + int unit; + int fontsize; + int hastable; + unsigned head0, head = head; + + /* test for psf first */ + if (len >= sizeof(struct psf_header) && PSF_MAGIC_OK(psfhdr)) { + if (psfhdr->mode > PSF_MAXMODE) + bb_error_msg_and_die("unsupported psf file mode"); + fontsize = ((psfhdr->mode & PSF_MODE512) ? 512 : 256); +#if !defined(PIO_FONTX) || defined(__sparc__) + if (fontsize != 256) + bb_error_msg_and_die("only fontsize 256 supported"); #endif - bb_perror_msg_and_die("PIO_UNIMAP"); + hastable = (psfhdr->mode & PSF_MODEHASTAB); + unit = psfhdr->charsize; + head0 = sizeof(struct psf_header); + + head = head0 + fontsize * unit; + if (head > len || (!hastable && head != len)) + bb_error_msg_and_die("input file: bad length"); + } else { + /* file with three code pages? */ + if (len == 9780) { + head0 = 40; + unit = 16; + } else { + /* bare font */ + if (len & 0377) + bb_error_msg_and_die("input file: bad length"); + head0 = 0; + unit = len / 256; + } + fontsize = 256; + hastable = 0; } + + do_loadfont(fd, (unsigned char *)psfhdr + head0, unit, fontsize); + if (hastable) + do_loadtable(fd, (unsigned char *)psfhdr + head, len - head, fontsize); } -static void loadnewfont(int fd) +#if ENABLE_LOADFONT +int loadfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int loadfont_main(int argc UNUSED_PARAM, char **argv) { - int unit; - char inbuf[32768]; /* primitive */ - unsigned int inputlth, offset; + size_t len; + struct psf_header *psfhdr; + + // no arguments allowed! + opt_complementary = "=0"; + getopt32(argv, ""); /* * We used to look at the length of the input file * with stat(); now that we accept compressed files, * just read the entire file. */ - inputlth = fread(inbuf, 1, sizeof(inbuf), stdin); - if (ferror(stdin)) - bb_perror_msg_and_die("Error reading input font"); - /* use malloc/realloc in case of giant files; - maybe these do not occur: 16kB for the font, - and 16kB for the map leaves 32 unicode values - for each font position */ - if (!feof(stdin)) - bb_perror_msg_and_die("Font too large"); + len = 32*1024; // can't be larger + psfhdr = xmalloc_read(STDIN_FILENO, &len); + // xmalloc_open_zipped_read_close(filename, &len); + if (!psfhdr) + bb_perror_msg_and_die("error reading input font"); + do_load(get_console_fd_or_die(), psfhdr, len); - /* test for psf first */ - { - struct psf_header psfhdr; - int fontsize; - int hastable; - unsigned int head0, head; + return EXIT_SUCCESS; +} +#endif + +#if ENABLE_SETFONT - if (inputlth < sizeof(struct psf_header)) - goto no_psf; +/* +kbd-1.12: - psfhdr = *(struct psf_header *) &inbuf[0]; +setfont [-O font+umap.orig] [-o font.orig] [-om cmap.orig] +[-ou umap.orig] [-N] [font.new ...] [-m cmap] [-u umap] [-C console] +[-hNN] [-v] [-V] - if (!PSF_MAGIC_OK(psfhdr)) - goto no_psf; +-h NN Override font height +-o file + Save previous font in file +-O file + Save previous font and Unicode map in file +-om file + Store console map in file +-ou file + Save previous Unicode map in file +-m file + Load console map or Unicode console map from file +-u file + Load Unicode table describing the font from file + Example: + # cp866 + 0x00-0x7f idem + # + 0x80 U+0410 # CYRILLIC CAPITAL LETTER A + 0x81 U+0411 # CYRILLIC CAPITAL LETTER BE + 0x82 U+0412 # CYRILLIC CAPITAL LETTER VE +-C console + Set the font for the indicated console +-v Verbose +-V Version +*/ - if (psfhdr.mode > PSF_MAXMODE) - bb_error_msg_and_die("Unsupported psf file mode"); - fontsize = ((psfhdr.mode & PSF_MODE512) ? 512 : 256); -#if !defined( PIO_FONTX ) || defined( __sparc__ ) - if (fontsize != 256) - bb_error_msg_and_die("Only fontsize 256 supported"); +#if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP +static int ctoi(char *s) +{ + if (s[0] == '\'' && s[1] != '\0' && s[2] == '\'' && s[3] == '\0') + return s[1]; + // U+ means 0x + if (s[0] == 'U' && s[1] == '+') { + s[0] = '0'; + s[1] = 'x'; + } + if (!isdigit(s[0])) + return -1; + return xstrtoul(s, 0); +} #endif - hastable = (psfhdr.mode & PSF_MODEHASTAB); - unit = psfhdr.charsize; - head0 = sizeof(struct psf_header); - head = head0 + fontsize * unit; - if (head > inputlth || (!hastable && head != inputlth)) - bb_error_msg_and_die("Input file: bad length"); - do_loadfont(fd, inbuf + head0, unit, fontsize); - if (hastable) - do_loadtable(fd, inbuf + head, inputlth - head, fontsize); - return; +int setfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int setfont_main(int argc UNUSED_PARAM, char **argv) +{ + size_t len; + unsigned opts; + int fd; + struct psf_header *psfhdr; + char *mapfilename; + const char *tty_name = CURRENT_TTY; + + opt_complementary = "=1"; + opts = getopt32(argv, "m:C:", &mapfilename, &tty_name); + argv += optind; + + fd = xopen(tty_name, O_NONBLOCK); + + if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not "" + if (*argv[0] != '/') { + // goto default fonts location. don't die if doesn't exist + chdir(CONFIG_DEFAULT_SETFONT_DIR "/consolefonts"); + } } - no_psf: + // load font + len = 32*1024; // can't be larger + psfhdr = xmalloc_open_zipped_read_close(*argv, &len); + if (!psfhdr) + bb_simple_perror_msg_and_die(*argv); + do_load(fd, psfhdr, len); - /* file with three code pages? */ - if (inputlth == 9780) { - offset = 40; - unit = 16; - } else { - /* bare font */ - if (inputlth & 0377) - bb_error_msg_and_die("Bad input file size"); - offset = 0; - unit = inputlth / 256; + // load the screen map, if any + if (opts & 1) { // -m + unsigned mode = PIO_SCRNMAP; + void *map; + + if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not "" + if (mapfilename[0] != '/') { + // goto default keymaps location + chdir(CONFIG_DEFAULT_SETFONT_DIR "/consoletrans"); + } + } + // fetch keymap + map = xmalloc_open_zipped_read_close(mapfilename, &len); + if (!map) + bb_simple_perror_msg_and_die(mapfilename); + // file size is 256 or 512 bytes? -> assume binary map + if (len == E_TABSZ || len == 2*E_TABSZ) { + if (len == 2*E_TABSZ) + mode = PIO_UNISCRNMAP; + } +#if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP + // assume textual Unicode console maps: + // 0x00 U+0000 # NULL (NUL) + // 0x01 U+0001 # START OF HEADING (SOH) + // 0x02 U+0002 # START OF TEXT (STX) + // 0x03 U+0003 # END OF TEXT (ETX) + else { + int i; + char *token[2]; + parser_t *parser; + + if (ENABLE_FEATURE_CLEAN_UP) + free(map); + map = xmalloc(E_TABSZ * sizeof(unsigned short)); + +#define unicodes ((unsigned short *)map) + // fill vanilla map + for (i = 0; i < E_TABSZ; i++) + unicodes[i] = 0xf000 + i; + + parser = config_open(mapfilename); + while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL | PARSE_MIN_DIE)) { + // parse code/value pair + int a = ctoi(token[0]); + int b = ctoi(token[1]); + if (a < 0 || a >= E_TABSZ + || b < 0 || b > 65535 + ) { + bb_error_msg_and_die("map format"); + } + // patch map + unicodes[a] = b; + // unicode character is met? + if (b > 255) + mode = PIO_UNISCRNMAP; + } + if (ENABLE_FEATURE_CLEAN_UP) + config_close(parser); + + if (mode != PIO_UNISCRNMAP) { +#define asciis ((unsigned char *)map) + for (i = 0; i < E_TABSZ; i++) + asciis[i] = unicodes[i]; +#undef asciis + } +#undef unicodes + } +#endif // ENABLE_FEATURE_SETFONT_TEXTUAL_MAP + + // do set screen map + xioctl(fd, mode, map); + + if (ENABLE_FEATURE_CLEAN_UP) + free(map); } - do_loadfont(fd, inbuf + offset, unit, 256); + + return EXIT_SUCCESS; } +#endif -- cgit v1.2.3-54-g00ecf