1/* 2 * Copyright (C) 1984-2023 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information, see the README file. 8 */ 9 10 11/* 12 * Routines to decode user commands. 13 * 14 * This is all table driven. 15 * A command table is a sequence of command descriptors. 16 * Each command descriptor is a sequence of bytes with the following format: 17 * <c1><c2>...<cN><0><action> 18 * The characters c1,c2,...,cN are the command string; that is, 19 * the characters which the user must type. 20 * It is terminated by a null <0> byte. 21 * The byte after the null byte is the action code associated 22 * with the command string. 23 * If an action byte is OR-ed with A_EXTRA, this indicates 24 * that the option byte is followed by an extra string. 25 * 26 * There may be many command tables. 27 * The first (default) table is built-in. 28 * Other tables are read in from "lesskey" files. 29 * All the tables are linked together and are searched in order. 30 */ 31 32#include "less.h" 33#include "cmd.h" 34#include "lesskey.h" 35 36extern int erase_char, erase2_char, kill_char; 37extern int secure; 38extern int mousecap; 39extern int screen_trashed; 40extern int sc_height; 41 42#define SK(k) \ 43 SK_SPECIAL_KEY, (k), 6, 1, 1, 1 44/* 45 * Command table is ordered roughly according to expected 46 * frequency of use, so the common commands are near the beginning. 47 */ 48 49static unsigned char cmdtable[] = 50{ 51 '\r',0, A_F_LINE, 52 '\n',0, A_F_LINE, 53 'e',0, A_F_LINE, 54 'j',0, A_F_LINE, 55 SK(SK_DOWN_ARROW),0, A_F_LINE, 56 CONTROL('E'),0, A_F_LINE, 57 CONTROL('N'),0, A_F_LINE, 58 'k',0, A_B_LINE, 59 'y',0, A_B_LINE, 60 CONTROL('Y'),0, A_B_LINE, 61 SK(SK_CONTROL_K),0, A_B_LINE, 62 CONTROL('P'),0, A_B_LINE, 63 SK(SK_UP_ARROW),0, A_B_LINE, 64 'J',0, A_FF_LINE, 65 'K',0, A_BF_LINE, 66 'Y',0, A_BF_LINE, 67 'd',0, A_F_SCROLL, 68 CONTROL('D'),0, A_F_SCROLL, 69 'u',0, A_B_SCROLL, 70 CONTROL('U'),0, A_B_SCROLL, 71 ESC,'[','M',0, A_X11MOUSE_IN, 72 ESC,'[','<',0, A_X116MOUSE_IN, 73 ' ',0, A_F_SCREEN, 74 'f',0, A_F_SCREEN, 75 CONTROL('F'),0, A_F_SCREEN, 76 CONTROL('V'),0, A_F_SCREEN, 77 SK(SK_PAGE_DOWN),0, A_F_SCREEN, 78 'b',0, A_B_SCREEN, 79 CONTROL('B'),0, A_B_SCREEN, 80 ESC,'v',0, A_B_SCREEN, 81 SK(SK_PAGE_UP),0, A_B_SCREEN, 82 'z',0, A_F_WINDOW, 83 'w',0, A_B_WINDOW, 84 ESC,' ',0, A_FF_SCREEN, 85 'F',0, A_F_FOREVER, 86 ESC,'F',0, A_F_UNTIL_HILITE, 87 'R',0, A_FREPAINT, 88 'r',0, A_REPAINT, 89 CONTROL('R'),0, A_REPAINT, 90 CONTROL('L'),0, A_REPAINT, 91 ESC,'u',0, A_UNDO_SEARCH, 92 ESC,'U',0, A_CLR_SEARCH, 93 'g',0, A_GOLINE, 94 SK(SK_HOME),0, A_GOLINE, 95 '<',0, A_GOLINE, 96 ESC,'<',0, A_GOLINE, 97 'p',0, A_PERCENT, 98 '%',0, A_PERCENT, 99 ESC,'[',0, A_LSHIFT, 100 ESC,']',0, A_RSHIFT, 101 ESC,'(',0, A_LSHIFT, 102 ESC,')',0, A_RSHIFT, 103 ESC,'{',0, A_LLSHIFT, 104 ESC,'}',0, A_RRSHIFT, 105 SK(SK_RIGHT_ARROW),0, A_RSHIFT, 106 SK(SK_LEFT_ARROW),0, A_LSHIFT, 107 SK(SK_CTL_RIGHT_ARROW),0, A_RRSHIFT, 108 SK(SK_CTL_LEFT_ARROW),0, A_LLSHIFT, 109 '{',0, A_F_BRACKET|A_EXTRA, '{','}',0, 110 '}',0, A_B_BRACKET|A_EXTRA, '{','}',0, 111 '(',0, A_F_BRACKET|A_EXTRA, '(',')',0, 112 ')',0, A_B_BRACKET|A_EXTRA, '(',')',0, 113 '[',0, A_F_BRACKET|A_EXTRA, '[',']',0, 114 ']',0, A_B_BRACKET|A_EXTRA, '[',']',0, 115 ESC,CONTROL('F'),0, A_F_BRACKET, 116 ESC,CONTROL('B'),0, A_B_BRACKET, 117 'G',0, A_GOEND, 118 ESC,'G',0, A_GOEND_BUF, 119 ESC,'>',0, A_GOEND, 120 '>',0, A_GOEND, 121 SK(SK_END),0, A_GOEND, 122 'P',0, A_GOPOS, 123 124 '0',0, A_DIGIT, 125 '1',0, A_DIGIT, 126 '2',0, A_DIGIT, 127 '3',0, A_DIGIT, 128 '4',0, A_DIGIT, 129 '5',0, A_DIGIT, 130 '6',0, A_DIGIT, 131 '7',0, A_DIGIT, 132 '8',0, A_DIGIT, 133 '9',0, A_DIGIT, 134 '.',0, A_DIGIT, 135 136 '=',0, A_STAT, 137 CONTROL('G'),0, A_STAT, 138 ':','f',0, A_STAT, 139 '/',0, A_F_SEARCH, 140 '?',0, A_B_SEARCH, 141 ESC,'/',0, A_F_SEARCH|A_EXTRA, '*',0, 142 ESC,'?',0, A_B_SEARCH|A_EXTRA, '*',0, 143 'n',0, A_AGAIN_SEARCH, 144 ESC,'n',0, A_T_AGAIN_SEARCH, 145 'N',0, A_REVERSE_SEARCH, 146 ESC,'N',0, A_T_REVERSE_SEARCH, 147 '&',0, A_FILTER, 148 'm',0, A_SETMARK, 149 'M',0, A_SETMARKBOT, 150 ESC,'m',0, A_CLRMARK, 151 '\'',0, A_GOMARK, 152 CONTROL('X'),CONTROL('X'),0, A_GOMARK, 153 'E',0, A_EXAMINE, 154 ':','e',0, A_EXAMINE, 155 CONTROL('X'),CONTROL('V'),0, A_EXAMINE, 156 ':','n',0, A_NEXT_FILE, 157 ':','p',0, A_PREV_FILE, 158 't',0, A_NEXT_TAG, 159 'T',0, A_PREV_TAG, 160 ':','x',0, A_INDEX_FILE, 161 ':','d',0, A_REMOVE_FILE, 162 '-',0, A_OPT_TOGGLE, 163 ':','t',0, A_OPT_TOGGLE|A_EXTRA, 't',0, 164 's',0, A_OPT_TOGGLE|A_EXTRA, 'o',0, 165 '_',0, A_DISP_OPTION, 166 '|',0, A_PIPE, 167 'v',0, A_VISUAL, 168 '!',0, A_SHELL, 169 '#',0, A_PSHELL, 170 '+',0, A_FIRSTCMD, 171 172 'H',0, A_HELP, 173 'h',0, A_HELP, 174 SK(SK_F1),0, A_HELP, 175 'V',0, A_VERSION, 176 'q',0, A_QUIT, 177 'Q',0, A_QUIT, 178 ':','q',0, A_QUIT, 179 ':','Q',0, A_QUIT, 180 'Z','Z',0, A_QUIT 181}; 182 183static unsigned char edittable[] = 184{ 185 '\t',0, EC_F_COMPLETE, /* TAB */ 186 '\17',0, EC_B_COMPLETE, /* BACKTAB */ 187 SK(SK_BACKTAB),0, EC_B_COMPLETE, /* BACKTAB */ 188 ESC,'\t',0, EC_B_COMPLETE, /* ESC TAB */ 189 CONTROL('L'),0, EC_EXPAND, /* CTRL-L */ 190 CONTROL('V'),0, EC_LITERAL, /* BACKSLASH */ 191 CONTROL('A'),0, EC_LITERAL, /* BACKSLASH */ 192 ESC,'l',0, EC_RIGHT, /* ESC l */ 193 SK(SK_RIGHT_ARROW),0, EC_RIGHT, /* RIGHTARROW */ 194 ESC,'h',0, EC_LEFT, /* ESC h */ 195 SK(SK_LEFT_ARROW),0, EC_LEFT, /* LEFTARROW */ 196 ESC,'b',0, EC_W_LEFT, /* ESC b */ 197 ESC,SK(SK_LEFT_ARROW),0, EC_W_LEFT, /* ESC LEFTARROW */ 198 SK(SK_CTL_LEFT_ARROW),0, EC_W_LEFT, /* CTRL-LEFTARROW */ 199 ESC,'w',0, EC_W_RIGHT, /* ESC w */ 200 ESC,SK(SK_RIGHT_ARROW),0, EC_W_RIGHT, /* ESC RIGHTARROW */ 201 SK(SK_CTL_RIGHT_ARROW),0, EC_W_RIGHT, /* CTRL-RIGHTARROW */ 202 ESC,'i',0, EC_INSERT, /* ESC i */ 203 SK(SK_INSERT),0, EC_INSERT, /* INSERT */ 204 ESC,'x',0, EC_DELETE, /* ESC x */ 205 SK(SK_DELETE),0, EC_DELETE, /* DELETE */ 206 ESC,'X',0, EC_W_DELETE, /* ESC X */ 207 ESC,SK(SK_DELETE),0, EC_W_DELETE, /* ESC DELETE */ 208 SK(SK_CTL_DELETE),0, EC_W_DELETE, /* CTRL-DELETE */ 209 SK(SK_CTL_BACKSPACE),0, EC_W_BACKSPACE, /* CTRL-BACKSPACE */ 210 ESC,SK(SK_BACKSPACE),0, EC_W_BACKSPACE, /* ESC BACKSPACE */ 211 ESC,'0',0, EC_HOME, /* ESC 0 */ 212 SK(SK_HOME),0, EC_HOME, /* HOME */ 213 ESC,'$',0, EC_END, /* ESC $ */ 214 SK(SK_END),0, EC_END, /* END */ 215 ESC,'k',0, EC_UP, /* ESC k */ 216 SK(SK_UP_ARROW),0, EC_UP, /* UPARROW */ 217 ESC,'j',0, EC_DOWN, /* ESC j */ 218 SK(SK_DOWN_ARROW),0, EC_DOWN, /* DOWNARROW */ 219 CONTROL('G'),0, EC_ABORT, /* CTRL-G */ 220 ESC,'[','M',0, EC_X11MOUSE, /* X11 mouse report */ 221 ESC,'[','<',0, EC_X116MOUSE, /* X11 1006 mouse report */ 222}; 223 224/* 225 * Structure to support a list of command tables. 226 */ 227struct tablelist 228{ 229 struct tablelist *t_next; 230 char *t_start; 231 char *t_end; 232}; 233 234/* 235 * List of command tables and list of line-edit tables. 236 */ 237static struct tablelist *list_fcmd_tables = NULL; 238static struct tablelist *list_ecmd_tables = NULL; 239static struct tablelist *list_var_tables = NULL; 240static struct tablelist *list_sysvar_tables = NULL; 241 242 243/* 244 * Expand special key abbreviations in a command table. 245 */ 246static void expand_special_keys(char *table, int len) 247{ 248 char *fm; 249 char *to; 250 int a; 251 char *repl; 252 int klen; 253 254 for (fm = table; fm < table + len; ) 255 { 256 /* 257 * Rewrite each command in the table with any 258 * special key abbreviations expanded. 259 */ 260 for (to = fm; *fm != '\0'; ) 261 { 262 if (*fm != SK_SPECIAL_KEY) 263 { 264 *to++ = *fm++; 265 continue; 266 } 267 /* 268 * After SK_SPECIAL_KEY, next byte is the type 269 * of special key (one of the SK_* constants), 270 * and the byte after that is the number of bytes, 271 * N, reserved by the abbreviation (including the 272 * SK_SPECIAL_KEY and key type bytes). 273 * Replace all N bytes with the actual bytes 274 * output by the special key on this terminal. 275 */ 276 repl = special_key_str(fm[1]); 277 klen = fm[2] & 0377; 278 fm += klen; 279 if (repl == NULL || (int) strlen(repl) > klen) 280 repl = "\377"; 281 while (*repl != '\0') 282 *to++ = *repl++; 283 } 284 *to++ = '\0'; 285 /* 286 * Fill any unused bytes between end of command and 287 * the action byte with A_SKIP. 288 */ 289 while (to <= fm) 290 *to++ = A_SKIP; 291 fm++; 292 a = *fm++ & 0377; 293 if (a & A_EXTRA) 294 { 295 while (*fm++ != '\0') 296 continue; 297 } 298 } 299} 300 301/* 302 * Expand special key abbreviations in a list of command tables. 303 */ 304static void expand_cmd_table(struct tablelist *tlist) 305{ 306 struct tablelist *t; 307 for (t = tlist; t != NULL; t = t->t_next) 308 { 309 expand_special_keys(t->t_start, t->t_end - t->t_start); 310 } 311} 312 313/* 314 * Expand special key abbreviations in all command tables. 315 */ 316public void expand_cmd_tables(void) 317{ 318 expand_cmd_table(list_fcmd_tables); 319 expand_cmd_table(list_ecmd_tables); 320 expand_cmd_table(list_var_tables); 321 expand_cmd_table(list_sysvar_tables); 322} 323 324 325/* 326 * Initialize the command lists. 327 */ 328public void init_cmds(void) 329{ 330 /* 331 * Add the default command tables. 332 */ 333 add_fcmd_table((char*)cmdtable, sizeof(cmdtable)); 334 add_ecmd_table((char*)edittable, sizeof(edittable)); 335#if USERFILE 336#ifdef BINDIR /* For backwards compatibility */ 337 /* Try to add tables in the OLD system lesskey file. */ 338 add_hometable(lesskey, NULL, BINDIR "/.sysless", 1); 339#endif 340 /* 341 * Try to load lesskey source file or binary file. 342 * If the source file succeeds, don't load binary file. 343 * The binary file is likely to have been generated from 344 * a (possibly out of date) copy of the src file, 345 * so loading it is at best redundant. 346 */ 347 /* 348 * Try to add tables in system lesskey src file. 349 */ 350#if HAVE_LESSKEYSRC 351 if (add_hometable(lesskey_src, "LESSKEYIN_SYSTEM", LESSKEYINFILE_SYS, 1) != 0) 352#endif 353 { 354 /* 355 * Try to add the tables in the system lesskey binary file. 356 */ 357 add_hometable(lesskey, "LESSKEY_SYSTEM", LESSKEYFILE_SYS, 1); 358 } 359 /* 360 * Try to add tables in the lesskey src file "$HOME/.lesskey". 361 */ 362#if HAVE_LESSKEYSRC 363 if (add_hometable(lesskey_src, "LESSKEYIN", DEF_LESSKEYINFILE, 0) != 0) 364#endif 365 { 366 /* 367 * Try to add the tables in the standard lesskey binary file "$HOME/.less". 368 */ 369 add_hometable(lesskey, "LESSKEY", LESSKEYFILE, 0); 370 } 371#endif 372} 373 374/* 375 * Add a command table. 376 */ 377static int add_cmd_table(struct tablelist **tlist, char *buf, int len) 378{ 379 struct tablelist *t; 380 381 if (len == 0) 382 return (0); 383 /* 384 * Allocate a tablelist structure, initialize it, 385 * and link it into the list of tables. 386 */ 387 if ((t = (struct tablelist *) 388 calloc(1, sizeof(struct tablelist))) == NULL) 389 { 390 return (-1); 391 } 392 t->t_start = buf; 393 t->t_end = buf + len; 394 t->t_next = *tlist; 395 *tlist = t; 396 return (0); 397} 398 399/* 400 * Add a command table. 401 */ 402public void add_fcmd_table(char *buf, int len) 403{ 404 if (add_cmd_table(&list_fcmd_tables, buf, len) < 0) 405 error("Warning: some commands disabled", NULL_PARG); 406} 407 408/* 409 * Add an editing command table. 410 */ 411public void add_ecmd_table(char *buf, int len) 412{ 413 if (add_cmd_table(&list_ecmd_tables, buf, len) < 0) 414 error("Warning: some edit commands disabled", NULL_PARG); 415} 416 417/* 418 * Add an environment variable table. 419 */ 420static void add_var_table(struct tablelist **tlist, char *buf, int len) 421{ 422 if (add_cmd_table(tlist, buf, len) < 0) 423 error("Warning: environment variables from lesskey file unavailable", NULL_PARG); 424} 425 426/* 427 * Return action for a mouse wheel down event. 428 */ 429static int mouse_wheel_down(void) 430{ 431 return ((mousecap == OPT_ONPLUS) ? A_B_MOUSE : A_F_MOUSE); 432} 433 434/* 435 * Return action for a mouse wheel up event. 436 */ 437static int mouse_wheel_up(void) 438{ 439 return ((mousecap == OPT_ONPLUS) ? A_F_MOUSE : A_B_MOUSE); 440} 441 442/* 443 * Return action for a mouse button release event. 444 */ 445static int mouse_button_rel(int x, int y) 446{ 447 /* 448 * {{ It would be better to return an action and then do this 449 * in commands() but it's nontrivial to pass y to it. }} 450 */ 451 if (y < sc_height-1) 452 { 453 setmark('#', y); 454 screen_trashed = 1; 455 } 456 return (A_NOACTION); 457} 458 459/* 460 * Read a decimal integer. Return the integer and set *pterm to the terminating char. 461 */ 462static int getcc_int(char *pterm) 463{ 464 int num = 0; 465 int digits = 0; 466 for (;;) 467 { 468 char ch = getcc(); 469 if (ch < '0' || ch > '9') 470 { 471 if (pterm != NULL) *pterm = ch; 472 if (digits == 0) 473 return (-1); 474 return (num); 475 } 476 if (ckd_mul(&num, num, 10) || ckd_add(&num, num, ch - '0')) 477 return -1; 478 ++digits; 479 } 480} 481 482/* 483 * Read suffix of mouse input and return the action to take. 484 * The prefix ("\e[M") has already been read. 485 */ 486static int x11mouse_action(int skip) 487{ 488 int b = getcc() - X11MOUSE_OFFSET; 489 int x = getcc() - X11MOUSE_OFFSET-1; 490 int y = getcc() - X11MOUSE_OFFSET-1; 491 if (skip) 492 return (A_NOACTION); 493 switch (b) { 494 default: 495 return (A_NOACTION); 496 case X11MOUSE_WHEEL_DOWN: 497 return mouse_wheel_down(); 498 case X11MOUSE_WHEEL_UP: 499 return mouse_wheel_up(); 500 case X11MOUSE_BUTTON_REL: 501 return mouse_button_rel(x, y); 502 } 503} 504 505/* 506 * Read suffix of mouse input and return the action to take. 507 * The prefix ("\e[<") has already been read. 508 */ 509static int x116mouse_action(int skip) 510{ 511 char ch; 512 int x, y; 513 int b = getcc_int(&ch); 514 if (b < 0 || ch != ';') return (A_NOACTION); 515 x = getcc_int(&ch) - 1; 516 if (x < 0 || ch != ';') return (A_NOACTION); 517 y = getcc_int(&ch) - 1; 518 if (y < 0) return (A_NOACTION); 519 if (skip) 520 return (A_NOACTION); 521 switch (b) { 522 case X11MOUSE_WHEEL_DOWN: 523 return mouse_wheel_down(); 524 case X11MOUSE_WHEEL_UP: 525 return mouse_wheel_up(); 526 default: 527 if (ch != 'm') return (A_NOACTION); 528 return mouse_button_rel(x, y); 529 } 530} 531 532/* 533 * Search a single command table for the command string in cmd. 534 */ 535static int cmd_search(char *cmd, char *table, char *endtable, char **sp) 536{ 537 char *p; 538 char *q; 539 int a; 540 541 *sp = NULL; 542 for (p = table, q = cmd; p < endtable; p++, q++) 543 { 544 if (*p == *q) 545 { 546 /* 547 * Current characters match. 548 * If we're at the end of the string, we've found it. 549 * Return the action code, which is the character 550 * after the null at the end of the string 551 * in the command table. 552 */ 553 if (*p == '\0') 554 { 555 a = *++p & 0377; 556 while (a == A_SKIP) 557 a = *++p & 0377; 558 if (a == A_END_LIST) 559 { 560 /* 561 * We get here only if the original 562 * cmd string passed in was empty (""). 563 * I don't think that can happen, 564 * but just in case ... 565 */ 566 return (A_UINVALID); 567 } 568 /* 569 * Check for an "extra" string. 570 */ 571 if (a & A_EXTRA) 572 { 573 *sp = ++p; 574 a &= ~A_EXTRA; 575 } 576 if (a == A_X11MOUSE_IN) 577 a = x11mouse_action(0); 578 else if (a == A_X116MOUSE_IN) 579 a = x116mouse_action(0); 580 return (a); 581 } 582 } else if (*q == '\0') 583 { 584 /* 585 * Hit the end of the user's command, 586 * but not the end of the string in the command table. 587 * The user's command is incomplete. 588 */ 589 return (A_PREFIX); 590 } else 591 { 592 /* 593 * Not a match. 594 * Skip ahead to the next command in the 595 * command table, and reset the pointer 596 * to the beginning of the user's command. 597 */ 598 if (*p == '\0' && p[1] == A_END_LIST) 599 { 600 /* 601 * A_END_LIST is a special marker that tells 602 * us to abort the cmd search. 603 */ 604 return (A_UINVALID); 605 } 606 while (*p++ != '\0') 607 continue; 608 while (*p == A_SKIP) 609 p++; 610 if (*p & A_EXTRA) 611 while (*++p != '\0') 612 continue; 613 q = cmd-1; 614 } 615 } 616 /* 617 * No match found in the entire command table. 618 */ 619 return (A_INVALID); 620} 621 622/* 623 * Decode a command character and return the associated action. 624 * The "extra" string, if any, is returned in sp. 625 */ 626static int cmd_decode(struct tablelist *tlist, char *cmd, char **sp) 627{ 628 struct tablelist *t; 629 int action = A_INVALID; 630 631 /* 632 * Search thru all the command tables. 633 * Stop when we find an action which is not A_INVALID. 634 */ 635 for (t = tlist; t != NULL; t = t->t_next) 636 { 637 action = cmd_search(cmd, t->t_start, t->t_end, sp); 638 if (action != A_INVALID) 639 break; 640 } 641 if (action == A_UINVALID) 642 action = A_INVALID; 643 return (action); 644} 645 646/* 647 * Decode a command from the cmdtables list. 648 */ 649public int fcmd_decode(char *cmd, char **sp) 650{ 651 return (cmd_decode(list_fcmd_tables, cmd, sp)); 652} 653 654/* 655 * Decode a command from the edittables list. 656 */ 657public int ecmd_decode(char *cmd, char **sp) 658{ 659 return (cmd_decode(list_ecmd_tables, cmd, sp)); 660} 661 662/* 663 * Get the value of an environment variable. 664 * Looks first in the lesskey file, then in the real environment. 665 */ 666public char * lgetenv(char *var) 667{ 668 int a; 669 char *s; 670 671 a = cmd_decode(list_var_tables, var, &s); 672 if (a == EV_OK) 673 return (s); 674 s = getenv(var); 675 if (s != NULL && *s != '\0') 676 return (s); 677 a = cmd_decode(list_sysvar_tables, var, &s); 678 if (a == EV_OK) 679 return (s); 680 return (NULL); 681} 682 683/* 684 * Is a string null or empty? 685 */ 686public int isnullenv(char *s) 687{ 688 return (s == NULL || *s == '\0'); 689} 690 691#if USERFILE 692/* 693 * Get an "integer" from a lesskey file. 694 * Integers are stored in a funny format: 695 * two bytes, low order first, in radix KRADIX. 696 */ 697static int gint(char **sp) 698{ 699 int n; 700 701 n = *(*sp)++; 702 n += *(*sp)++ * KRADIX; 703 return (n); 704} 705 706/* 707 * Process an old (pre-v241) lesskey file. 708 */ 709static int old_lesskey(char *buf, int len) 710{ 711 /* 712 * Old-style lesskey file. 713 * The file must end with either 714 * ...,cmd,0,action 715 * or ...,cmd,0,action|A_EXTRA,string,0 716 * So the last byte or the second to last byte must be zero. 717 */ 718 if (buf[len-1] != '\0' && buf[len-2] != '\0') 719 return (-1); 720 add_fcmd_table(buf, len); 721 return (0); 722} 723 724/* 725 * Process a new (post-v241) lesskey file. 726 */ 727static int new_lesskey(char *buf, int len, int sysvar) 728{ 729 char *p; 730 char *end; 731 int c; 732 int n; 733 734 /* 735 * New-style lesskey file. 736 * Extract the pieces. 737 */ 738 if (buf[len-3] != C0_END_LESSKEY_MAGIC || 739 buf[len-2] != C1_END_LESSKEY_MAGIC || 740 buf[len-1] != C2_END_LESSKEY_MAGIC) 741 return (-1); 742 p = buf + 4; 743 end = buf + len; 744 for (;;) 745 { 746 c = *p++; 747 switch (c) 748 { 749 case CMD_SECTION: 750 n = gint(&p); 751 if (n < 0 || p+n >= end) 752 return (-1); 753 add_fcmd_table(p, n); 754 p += n; 755 break; 756 case EDIT_SECTION: 757 n = gint(&p); 758 if (n < 0 || p+n >= end) 759 return (-1); 760 add_ecmd_table(p, n); 761 p += n; 762 break; 763 case VAR_SECTION: 764 n = gint(&p); 765 if (n < 0 || p+n >= end) 766 return (-1); 767 add_var_table((sysvar) ? 768 &list_sysvar_tables : &list_var_tables, p, n); 769 p += n; 770 break; 771 case END_SECTION: 772 return (0); 773 default: 774 /* 775 * Unrecognized section type. 776 */ 777 return (-1); 778 } 779 } 780} 781 782/* 783 * Set up a user command table, based on a "lesskey" file. 784 */ 785public int lesskey(char *filename, int sysvar) 786{ 787 char *buf; 788 POSITION len; 789 long n; 790 int f; 791 792 if (secure) 793 return (1); 794 /* 795 * Try to open the lesskey file. 796 */ 797 f = open(filename, OPEN_READ); 798 if (f < 0) 799 return (1); 800 801 /* 802 * Read the file into a buffer. 803 * We first figure out the size of the file and allocate space for it. 804 * {{ Minimal error checking is done here. 805 * A garbage .less file will produce strange results. 806 * To avoid a large amount of error checking code here, we 807 * rely on the lesskey program to generate a good .less file. }} 808 */ 809 len = filesize(f); 810 if (len == NULL_POSITION || len < 3) 811 { 812 /* 813 * Bad file (valid file must have at least 3 chars). 814 */ 815 close(f); 816 return (-1); 817 } 818 if ((buf = (char *) calloc((int)len, sizeof(char))) == NULL) 819 { 820 close(f); 821 return (-1); 822 } 823 if (lseek(f, (off_t)0, SEEK_SET) == BAD_LSEEK) 824 { 825 free(buf); 826 close(f); 827 return (-1); 828 } 829 n = read(f, buf, (unsigned int) len); 830 close(f); 831 if (n != len) 832 { 833 free(buf); 834 return (-1); 835 } 836 837 /* 838 * Figure out if this is an old-style (before version 241) 839 * or new-style lesskey file format. 840 */ 841 if (len < 4 || 842 buf[0] != C0_LESSKEY_MAGIC || buf[1] != C1_LESSKEY_MAGIC || 843 buf[2] != C2_LESSKEY_MAGIC || buf[3] != C3_LESSKEY_MAGIC) 844 return (old_lesskey(buf, (int)len)); 845 return (new_lesskey(buf, (int)len, sysvar)); 846} 847 848#if HAVE_LESSKEYSRC 849public int lesskey_src(char *filename, int sysvar) 850{ 851 static struct lesskey_tables tables; 852 int r = parse_lesskey(filename, &tables); 853 if (r != 0) 854 return (r); 855 add_fcmd_table(xbuf_char_data(&tables.cmdtable.buf), tables.cmdtable.buf.end); 856 add_ecmd_table(xbuf_char_data(&tables.edittable.buf), tables.edittable.buf.end); 857 add_var_table(sysvar ? &list_sysvar_tables : &list_var_tables, 858 xbuf_char_data(&tables.vartable.buf), tables.vartable.buf.end); 859 return (0); 860} 861 862void lesskey_parse_error(char *s) 863{ 864 PARG parg; 865 parg.p_string = s; 866 error("%s", &parg); 867} 868#endif /* HAVE_LESSKEYSRC */ 869 870/* 871 * Add a lesskey file. 872 */ 873public int add_hometable(int (*call_lesskey)(char *, int), char *envname, char *def_filename, int sysvar) 874{ 875 char *filename; 876 int r; 877 878 if (envname != NULL && (filename = lgetenv(envname)) != NULL) 879 filename = save(filename); 880 else if (sysvar) /* def_filename is full path */ 881 filename = save(def_filename); 882 else /* def_filename is just basename */ 883 { 884 /* Remove first char (normally a dot) unless stored in $HOME. */ 885 char *xdg = lgetenv("XDG_CONFIG_HOME"); 886 if (!isnullenv(xdg)) 887 filename = dirfile(xdg, &def_filename[1], 1); 888 if (filename == NULL) 889 { 890 char *home = lgetenv("HOME"); 891 if (!isnullenv(home)) 892 { 893 char *cfg_dir = dirfile(home, ".config", 0); 894 filename = dirfile(cfg_dir, &def_filename[1], 1); 895 free(cfg_dir); 896 } 897 } 898 if (filename == NULL) 899 filename = homefile(def_filename); 900 } 901 if (filename == NULL) 902 return -1; 903 r = (*call_lesskey)(filename, sysvar); 904 free(filename); 905 return (r); 906} 907#endif 908 909/* 910 * See if a char is a special line-editing command. 911 */ 912public int editchar(int c, int flags) 913{ 914 int action; 915 int nch; 916 char *s; 917 char usercmd[MAX_CMDLEN+1]; 918 919 /* 920 * An editing character could actually be a sequence of characters; 921 * for example, an escape sequence sent by pressing the uparrow key. 922 * To match the editing string, we use the command decoder 923 * but give it the edit-commands command table 924 * This table is constructed to match the user's keyboard. 925 */ 926 if (c == erase_char || c == erase2_char) 927 return (EC_BACKSPACE); 928 if (c == kill_char) 929 { 930#if MSDOS_COMPILER==WIN32C 931 if (!win32_kbhit()) 932#endif 933 return (EC_LINEKILL); 934 } 935 936 /* 937 * Collect characters in a buffer. 938 * Start with the one we have, and get more if we need them. 939 */ 940 nch = 0; 941 do { 942 if (nch > 0) 943 c = getcc(); 944 usercmd[nch] = c; 945 usercmd[nch+1] = '\0'; 946 nch++; 947 action = ecmd_decode(usercmd, &s); 948 } while (action == A_PREFIX && nch < MAX_CMDLEN); 949 950 if (action == EC_X11MOUSE) 951 return (x11mouse_action(1)); 952 if (action == EC_X116MOUSE) 953 return (x116mouse_action(1)); 954 955 if (flags & ECF_NORIGHTLEFT) 956 { 957 switch (action) 958 { 959 case EC_RIGHT: 960 case EC_LEFT: 961 action = A_INVALID; 962 break; 963 } 964 } 965#if CMD_HISTORY 966 if (flags & ECF_NOHISTORY) 967 { 968 /* 969 * The caller says there is no history list. 970 * Reject any history-manipulation action. 971 */ 972 switch (action) 973 { 974 case EC_UP: 975 case EC_DOWN: 976 action = A_INVALID; 977 break; 978 } 979 } 980#endif 981#if TAB_COMPLETE_FILENAME 982 if (flags & ECF_NOCOMPLETE) 983 { 984 /* 985 * The caller says we don't want any filename completion cmds. 986 * Reject them. 987 */ 988 switch (action) 989 { 990 case EC_F_COMPLETE: 991 case EC_B_COMPLETE: 992 case EC_EXPAND: 993 action = A_INVALID; 994 break; 995 } 996 } 997#endif 998 if ((flags & ECF_PEEK) || action == A_INVALID) 999 { 1000 /* 1001 * We're just peeking, or we didn't understand the command. 1002 * Unget all the characters we read in the loop above. 1003 * This does NOT include the original character that was 1004 * passed in as a parameter. 1005 */ 1006 while (nch > 1) 1007 { 1008 ungetcc(usercmd[--nch]); 1009 } 1010 } else 1011 { 1012 if (s != NULL) 1013 ungetsc(s); 1014 } 1015 return action; 1016} 1017 1018