console-tools/loadfont.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * loadfont.c - Eugene Crosser & Andries Brouwer
   4  *
   5  * Version 0.96bb
   6  *
   7  * Loads the console font, and possibly the corresponding screen map(s).
   8  * (Adapted for busybox by Matej Vela.)
   9  */
  10 #include "libbb.h"
  11 #include <sys/kd.h>
  12
  13 #ifndef KDFONTOP
  14 #define KDFONTOP 0x4B72
  15 struct console_font_op {
  16         unsigned op;            /* KD_FONT_OP_* */
  17         unsigned flags;         /* KD_FONT_FLAG_* */
  18         unsigned width, height;
  19         unsigned charcount;
  20         unsigned char *data;    /* font data with height fixed to 32 */
  21 };
  22
  23 #define KD_FONT_OP_SET          0  /* Set font */
  24 #define KD_FONT_OP_GET          1  /* Get font */
  25 #define KD_FONT_OP_SET_DEFAULT  2  /* Set font to default,
  26                                          data points to name / NULL */
  27 #define KD_FONT_OP_COPY         3  /* Copy from another console */
  28
  29 #define KD_FONT_FLAG_OLD        0x80000000 /* Invoked via old interface */
  30 #define KD_FONT_FLAG_DONT_RECALC 1 /* Don't call adjust_height() */
  31                                    /* (Used internally for PIO_FONT support) */
  32 #endif /* KDFONTOP */
  33
  34
  35 enum {
  36         PSF_MAGIC1 = 0x36,
  37         PSF_MAGIC2 = 0x04,
  38
  39         PSF_MODE512 = 0x01,
  40         PSF_MODEHASTAB = 0x02,
  41         PSF_MAXMODE = 0x03,
  42         PSF_SEPARATOR = 0xffff
  43 };
  44
  45 struct psf_header {
  46         unsigned char magic1, magic2;   /* Magic number */
  47         unsigned char mode;             /* PSF font mode */
  48         unsigned char charsize;         /* Character size */
  49 };
  50
  51 #define PSF_MAGIC_OK(x) ((x)->magic1 == PSF_MAGIC1 && (x)->magic2 == PSF_MAGIC2)
  52
  53 static void do_loadfont(int fd, unsigned char *inbuf, int unit, int fontsize)
  54 {
  55         char *buf;
  56         int i;
  57
  58         if (unit < 1 || unit > 32)
  59                 bb_error_msg_and_die("bad character size %d", unit);
  60
  61         buf = xzalloc(16 * 1024);
  62         for (i = 0; i < fontsize; i++)
  63                 memcpy(buf + (32 * i), inbuf + (unit * i), unit);
  64
  65         { /* KDFONTOP */
  66                 struct console_font_op cfo;
  67
  68                 cfo.op = KD_FONT_OP_SET;
  69                 cfo.flags = 0;
  70                 cfo.width = 8;
  71                 cfo.height = unit;
  72                 cfo.charcount = fontsize;
  73                 cfo.data = (void*)buf;
  74 #if 0
  75                 if (!ioctl_or_perror(fd, KDFONTOP, &cfo, "KDFONTOP ioctl failed (will try PIO_FONTX)"))
  76                         goto ret;  /* success */
  77 #else
  78                 xioctl(fd, KDFONTOP, &cfo);
  79 #endif
  80         }
  81
  82 #if 0
  83 /* These ones do not honour -C tty (they set font on current tty regardless) */
  84 #if defined(PIO_FONTX) && !defined(__sparc__)
  85         {
  86                 struct consolefontdesc cfd;
  87
  88                 cfd.charcount = fontsize;
  89                 cfd.charheight = unit;
  90                 cfd.chardata = buf;
  91
  92                 if (!ioctl_or_perror(fd, PIO_FONTX, &cfd, "PIO_FONTX ioctl failed (will try PIO_FONT)"))
  93                         goto ret;  /* success */
  94         }
  95 #endif
  96         xioctl(fd, PIO_FONT, buf);
  97  ret:
  98 #endif /* 0 */
  99         free(buf);
 100 }
 101
 102 static void do_loadtable(int fd, unsigned char *inbuf, int tailsz, int fontsize)
 103 {
 104         struct unimapinit advice;
 105         struct unimapdesc ud;
 106         struct unipair *up;
 107         int ct = 0, maxct;
 108         int glyph;
 109         uint16_t unicode;
 110
 111         maxct = tailsz; /* more than enough */
 112         up = xmalloc(maxct * sizeof(struct unipair));
 113
 114         for (glyph = 0; glyph < fontsize; glyph++) {
 115                 while (tailsz >= 2) {
 116                         unicode = (((uint16_t) inbuf[1]) << 8) + inbuf[0];
 117                         tailsz -= 2;
 118                         inbuf += 2;
 119                         if (unicode == PSF_SEPARATOR)
 120                                 break;
 121                         up[ct].unicode = unicode;
 122                         up[ct].fontpos = glyph;
 123                         ct++;
 124                 }
 125         }
 126
 127         /* Note: after PIO_UNIMAPCLR and before PIO_UNIMAP
 128            this printf did not work on many kernels */
 129
 130         advice.advised_hashsize = 0;
 131         advice.advised_hashstep = 0;
 132         advice.advised_hashlevel = 0;
 133         xioctl(fd, PIO_UNIMAPCLR, &advice);
 134         ud.entry_ct = ct;
 135         ud.entries = up;
 136         xioctl(fd, PIO_UNIMAP, &ud);
 137 }
 138
 139 static void do_load(int fd, struct psf_header *psfhdr, size_t len)
 140 {
 141         int unit;
 142         int fontsize;
 143         int hastable;
 144         unsigned head0, head = head;
 145
 146         /* test for psf first */
 147         if (len >= sizeof(struct psf_header) && PSF_MAGIC_OK(psfhdr)) {
 148                 if (psfhdr->mode > PSF_MAXMODE)
 149                         bb_error_msg_and_die("unsupported psf file mode");
 150                 fontsize = ((psfhdr->mode & PSF_MODE512) ? 512 : 256);
 151 #if !defined(PIO_FONTX) || defined(__sparc__)
 152                 if (fontsize != 256)
 153                         bb_error_msg_and_die("only fontsize 256 supported");
 154 #endif
 155                 hastable = (psfhdr->mode & PSF_MODEHASTAB);
 156                 unit = psfhdr->charsize;
 157                 head0 = sizeof(struct psf_header);
 158
 159                 head = head0 + fontsize * unit;
 160                 if (head > len || (!hastable && head != len))
 161                         bb_error_msg_and_die("input file: bad length");
 162         } else {
 163                 /* file with three code pages? */
 164                 if (len == 9780) {
 165                         head0 = 40;
 166                         unit = 16;
 167                 } else {
 168                         /* bare font */
 169                         if (len & 0377)
 170                                 bb_error_msg_and_die("input file: bad length");
 171                         head0 = 0;
 172                         unit = len / 256;
 173                 }
 174                 fontsize = 256;
 175                 hastable = 0;
 176         }
 177
 178         do_loadfont(fd, (unsigned char *)psfhdr + head0, unit, fontsize);
 179         if (hastable)
 180                 do_loadtable(fd, (unsigned char *)psfhdr + head, len - head, fontsize);
 181 }
 182
 183 #if ENABLE_LOADFONT
 184 int loadfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 185 int loadfont_main(int argc UNUSED_PARAM, char **argv)
 186 {
 187         size_t len;
 188         struct psf_header *psfhdr;
 189
 190         // no arguments allowed!
 191         opt_complementary = "=0";
 192         getopt32(argv, "");
 193
 194         /*
 195          * We used to look at the length of the input file
 196          * with stat(); now that we accept compressed files,
 197          * just read the entire file.
 198          */
 199         len = 32*1024; // can't be larger
 200         psfhdr = xmalloc_read(STDIN_FILENO, &len);
 201         // xmalloc_open_zipped_read_close(filename, &len);
 202         if (!psfhdr)
 203                 bb_perror_msg_and_die("error reading input font");
 204         do_load(get_console_fd_or_die(), psfhdr, len);
 205
 206         return EXIT_SUCCESS;
 207 }
 208 #endif
 209
 210 #if ENABLE_SETFONT
 211
 212 /*
 213 kbd-1.12:
 214
 215 setfont [-O font+umap.orig] [-o font.orig] [-om cmap.orig]
 216 [-ou umap.orig] [-N] [font.new ...] [-m cmap] [-u umap] [-C console]
 217 [-hNN] [-v] [-V]
 218
 219 -h NN  Override font height
 220 -o file
 221        Save previous font in file
 222 -O file
 223        Save previous font and Unicode map in file
 224 -om file
 225        Store console map in file
 226 -ou file
 227        Save previous Unicode map in file
 228 -m file
 229        Load console map or Unicode console map from file
 230 -u file
 231        Load Unicode table describing the font from file
 232        Example:
 233        # cp866
 234        0x00-0x7f       idem
 235        #
 236        0x80    U+0410  # CYRILLIC CAPITAL LETTER A
 237        0x81    U+0411  # CYRILLIC CAPITAL LETTER BE
 238        0x82    U+0412  # CYRILLIC CAPITAL LETTER VE
 239 -C console
 240        Set the font for the indicated console
 241 -v     Verbose
 242 -V     Version
 243 */
 244
 245 #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP
 246 static int ctoi(char *s)
 247 {
 248         if (s[0] == '\'' && s[1] != '\0' && s[2] == '\'' && s[3] == '\0')
 249                 return s[1];
 250         // U+ means 0x
 251         if (s[0] == 'U' && s[1] == '+') {
 252                 s[0] = '0';
 253                 s[1] = 'x';
 254         }
 255         if (!isdigit(s[0]))
 256                 return -1;
 257         return xstrtoul(s, 0);
 258 }
 259 #endif
 260
 261 int setfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 262 int setfont_main(int argc UNUSED_PARAM, char **argv)
 263 {
 264         size_t len;
 265         unsigned opts;
 266         int fd;
 267         struct psf_header *psfhdr;
 268         char *mapfilename;
 269         const char *tty_name = CURRENT_TTY;
 270
 271         opt_complementary = "=1";
 272         opts = getopt32(argv, "m:C:", &mapfilename, &tty_name);
 273         argv += optind;
 274
 275         fd = xopen(tty_name, O_NONBLOCK);
 276
 277         if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not ""
 278                 if (*argv[0] != '/') {
 279                         // goto default fonts location. don't die if doesn't exist
 280                         chdir(CONFIG_DEFAULT_SETFONT_DIR "/consolefonts");
 281                 }
 282         }
 283         // load font
 284         len = 32*1024; // can't be larger
 285         psfhdr = xmalloc_open_zipped_read_close(*argv, &len);
 286         if (!psfhdr)
 287                 bb_simple_perror_msg_and_die(*argv);
 288         do_load(fd, psfhdr, len);
 289
 290         // load the screen map, if any
 291         if (opts & 1) { // -m
 292                 unsigned mode = PIO_SCRNMAP;
 293                 void *map;
 294
 295                 if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not ""
 296                         if (mapfilename[0] != '/') {
 297                                 // goto default keymaps location
 298                                 chdir(CONFIG_DEFAULT_SETFONT_DIR "/consoletrans");
 299                         }
 300                 }
 301                 // fetch keymap
 302                 map = xmalloc_open_zipped_read_close(mapfilename, &len);
 303                 if (!map)
 304                         bb_simple_perror_msg_and_die(mapfilename);
 305                 // file size is 256 or 512 bytes? -> assume binary map
 306                 if (len == E_TABSZ || len == 2*E_TABSZ) {
 307                         if (len == 2*E_TABSZ)
 308                                 mode = PIO_UNISCRNMAP;
 309                 }
 310 #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP
 311                 // assume textual Unicode console maps:
 312                 // 0x00 U+0000  #  NULL (NUL)
 313                 // 0x01 U+0001  #  START OF HEADING (SOH)
 314                 // 0x02 U+0002  #  START OF TEXT (STX)
 315                 // 0x03 U+0003  #  END OF TEXT (ETX)
 316                 else {
 317                         int i;
 318                         char *token[2];
 319                         parser_t *parser;
 320
 321                         if (ENABLE_FEATURE_CLEAN_UP)
 322                                 free(map);
 323                         map = xmalloc(E_TABSZ * sizeof(unsigned short));
 324
 325 #define unicodes ((unsigned short *)map)
 326                         // fill vanilla map
 327                         for (i = 0; i < E_TABSZ; i++)
 328                                 unicodes[i] = 0xf000 + i;
 329
 330                         parser = config_open(mapfilename);
 331                         while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL | PARSE_MIN_DIE)) {
 332                                 // parse code/value pair
 333                                 int a = ctoi(token[0]);
 334                                 int b = ctoi(token[1]);
 335                                 if (a < 0 || a >= E_TABSZ
 336                                  || b < 0 || b > 65535
 337                                 ) {
 338                                         bb_error_msg_and_die("map format");
 339                                 }
 340                                 // patch map
 341                                 unicodes[a] = b;
 342                                 // unicode character is met?
 343                                 if (b > 255)
 344                                         mode = PIO_UNISCRNMAP;
 345                         }
 346                         if (ENABLE_FEATURE_CLEAN_UP)
 347                                 config_close(parser);
 348
 349                         if (mode != PIO_UNISCRNMAP) {
 350 #define asciis ((unsigned char *)map)
 351                                 for (i = 0; i < E_TABSZ; i++)
 352                                         asciis[i] = unicodes[i];
 353 #undef asciis
 354                         }
 355 #undef unicodes
 356                 }
 357 #endif // ENABLE_FEATURE_SETFONT_TEXTUAL_MAP
 358
 359                 // do set screen map
 360                 xioctl(fd, mode, map);
 361
 362                 if (ENABLE_FEATURE_CLEAN_UP)
 363                         free(map);
 364         }
 365
 366         return EXIT_SUCCESS;
 367 }
 368 #endif