mirror of
https://github.com/sheumann/hush.git
synced 2024-08-21 11:28:57 +00:00
function old new delta do_iptunnel 203 977 +774 process_dev 5328 5494 +166 ioctl_or_perror - 54 +54 ioctl_or_perror_and_die - 51 +51 ioctl_alt_func - 49 +49 bb_ioctl_or_warn - 47 +47 do_add_ioctl 102 145 +43 bb_xioctl - 39 +39 print_value_on_off - 31 +31 get_lcm 105 123 +18 arp_main 2155 2167 +12 .................. zcip_main 1576 1566 -10 setlogcons_main 92 82 -10 dumpkmap_main 263 253 -10 do_get_ioctl 85 75 -10 setkeycodes_main 165 154 -11 write_table 244 232 -12 vconfig_main 318 306 -12 do_del_ioctl 93 81 -12 set_address 75 62 -13 maybe_set_utc 30 16 -14 loadfont_main 495 479 -16 slattach_main 712 695 -17 do_loadfont 191 174 -17 do_iplink 1155 1136 -19 getty_main 2583 2562 -21 fbset_main 2058 2035 -23 do_time 588 565 -23 xioctl 25 - -25 read_rtc 186 160 -26 parse_conf 1299 1270 -29 udhcp_read_interface 269 239 -30 bb_ioctl 45 - -45 bb_ioctl_alt 70 - -70 bb_ioctl_on_off 78 - -78 .rodata 129370 129018 -352 do_show 799 - -799 ------------------------------------------------------------------------------ (add/remove: 6/5 grow/shrink: 13/49 up/down: 1316/-1864) Total: -548 bytes text data bss dec hex filename 675352 2740 13968 692060 a8f5c busybox_old 674804 2740 13968 691512 a8d38 busybox_unstripped
182 lines
4.1 KiB
C
182 lines
4.1 KiB
C
/* vi: set sw=4 ts=4: */
|
|
/*
|
|
* loadfont.c - Eugene Crosser & Andries Brouwer
|
|
*
|
|
* Version 0.96bb
|
|
*
|
|
* Loads the console font, and possibly the corresponding screen map(s).
|
|
* (Adapted for busybox by Matej Vela.)
|
|
*/
|
|
#include "libbb.h"
|
|
#include <sys/kd.h>
|
|
|
|
enum {
|
|
PSF_MAGIC1 = 0x36,
|
|
PSF_MAGIC2 = 0x04,
|
|
|
|
PSF_MODE512 = 0x01,
|
|
PSF_MODEHASTAB = 0x02,
|
|
PSF_MAXMODE = 0x03,
|
|
PSF_SEPARATOR = 0xFFFF
|
|
};
|
|
|
|
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, unsigned char *inbuf, int unit, int fontsize)
|
|
{
|
|
char *buf;
|
|
int i;
|
|
|
|
if (unit < 1 || unit > 32)
|
|
bb_error_msg_and_die("bad character size %d", unit);
|
|
|
|
buf = xzalloc(16 * 1024);
|
|
/*memset(buf, 0, 16 * 1024);*/
|
|
for (i = 0; i < fontsize; i++)
|
|
memcpy(buf + (32 * i), inbuf + (unit * i), unit);
|
|
|
|
#if defined(PIO_FONTX) && !defined(__sparc__)
|
|
{
|
|
struct consolefontdesc cfd;
|
|
|
|
cfd.charcount = fontsize;
|
|
cfd.charheight = unit;
|
|
cfd.chardata = buf;
|
|
|
|
if (!ioctl_or_perror(fd, PIO_FONTX, &cfd, "PIO_FONTX ioctl failed (will try PIO_FONT)"))
|
|
goto ret; /* success */
|
|
}
|
|
#endif
|
|
xioctl(fd, PIO_FONT, buf);
|
|
ret:
|
|
free(buf);
|
|
}
|
|
|
|
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;
|
|
uint16_t unicode;
|
|
|
|
maxct = tailsz; /* more than enough */
|
|
up = xmalloc(maxct * sizeof(struct unipair));
|
|
|
|
for (glyph = 0; glyph < fontsize; glyph++) {
|
|
while (tailsz >= 2) {
|
|
unicode = (((uint16_t) inbuf[1]) << 8) + inbuf[0];
|
|
tailsz -= 2;
|
|
inbuf += 2;
|
|
if (unicode == PSF_SEPARATOR)
|
|
break;
|
|
up[ct].unicode = unicode;
|
|
up[ct].fontpos = glyph;
|
|
ct++;
|
|
}
|
|
}
|
|
|
|
/* Note: after PIO_UNIMAPCLR and before PIO_UNIMAP
|
|
this printf did not work on many kernels */
|
|
|
|
advice.advised_hashsize = 0;
|
|
advice.advised_hashstep = 0;
|
|
advice.advised_hashlevel = 0;
|
|
xioctl(fd, PIO_UNIMAPCLR, &advice);
|
|
ud.entry_ct = ct;
|
|
ud.entries = up;
|
|
xioctl(fd, PIO_UNIMAP, &ud);
|
|
}
|
|
|
|
static void loadnewfont(int fd)
|
|
{
|
|
enum { INBUF_SIZE = 32*1024 + 1 };
|
|
|
|
int unit;
|
|
unsigned inputlth, offset;
|
|
/* Was on stack, but 32k is a bit too much: */
|
|
unsigned char *inbuf = xmalloc(INBUF_SIZE);
|
|
|
|
/*
|
|
* 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 = full_read(STDIN_FILENO, inbuf, INBUF_SIZE);
|
|
if (inputlth < 0)
|
|
bb_perror_msg_and_die("error reading input font");
|
|
if (inputlth >= INBUF_SIZE)
|
|
bb_error_msg_and_die("font too large");
|
|
|
|
/* test for psf first */
|
|
{
|
|
struct psf_header psfhdr;
|
|
int fontsize;
|
|
int hastable;
|
|
unsigned head0, head;
|
|
|
|
if (inputlth < sizeof(struct psf_header))
|
|
goto no_psf;
|
|
|
|
psfhdr = *(struct psf_header *) &inbuf[0];
|
|
|
|
if (!PSF_MAGIC_OK(psfhdr))
|
|
goto no_psf;
|
|
|
|
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
|
|
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;
|
|
}
|
|
|
|
no_psf:
|
|
/* 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;
|
|
}
|
|
do_loadfont(fd, inbuf + offset, unit, 256);
|
|
}
|
|
|
|
int loadfont_main(int argc, char **argv);
|
|
int loadfont_main(int argc, char **argv)
|
|
{
|
|
int fd;
|
|
|
|
if (argc != 1)
|
|
bb_show_usage();
|
|
|
|
fd = xopen(CURRENT_VC, O_RDWR);
|
|
loadnewfont(fd);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|