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