1 /* $NetBSD: el.c,v 1.106 2026/11/14 17:50:15 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Christos Zoulas of Cornell University. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include "config.h" 36 #if !defined(lint) && !defined(SCCSID) 37 #if 0 38 static char sccsid[] = "@(#)el.c 8.2 (Berkeley) 1/3/94"; 39 #else 40 __RCSID("$NetBSD: el.c,v 1.106 2026/11/14 17:50:15 christos Exp $"); 41 #endif 42 #endif /* not lint && not SCCSID */ 43 44 /* 45 * el.c: EditLine interface functions 46 */ 47 #include <sys/types.h> 48 #include <sys/param.h> 49 #include <ctype.h> 50 #include <langinfo.h> 51 #include <locale.h> 52 #include <stdarg.h> 53 #include <stdlib.h> 54 #include <string.h> 55 56 #include "el.h" 57 #include "parse.h" 58 #include "read.h" 59 60 typedef char * (*func_t)(const char *); 61 62 /* el_init(): 63 * Initialize editline and set default parameters. 64 */ 65 EditLine * 66 el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr) 67 { 68 return el_init_fd(prog, fin, fout, ferr, fileno(fin), fileno(fout), 69 fileno(ferr)); 70 } 71 72 libedit_private EditLine * 73 el_init_internal(const char *prog, FILE *fin, FILE *fout, FILE *ferr, 74 int fdin, int fdout, int fderr, int flags) 75 { 76 EditLine *el = el_calloc(1, sizeof(*el)); 77 78 if (el == NULL) 79 return NULL; 80 81 el->el_infile = fin; 82 el->el_outfile = fout; 83 el->el_errfile = ferr; 84 85 el->el_infd = fdin; 86 el->el_outfd = fdout; 87 el->el_errfd = fderr; 88 89 el->el_getenv = getenv; 90 91 el->el_prog = wcsdup(ct_decode_string(prog, &el->el_scratch)); 92 if (el->el_prog == NULL) { 93 el_free(el); 94 return NULL; 95 } 96 97 /* 98 * Initialize all the modules. Order is important!!! 99 */ 100 el->el_flags = flags; 101 102 if (terminal_init(el) == -1) { 103 el_free(el->el_scratch.cbuff); 104 el_free(el->el_scratch.wbuff); 105 el_free(el->el_prog); 106 el_free(el); 107 return NULL; 108 } 109 (void) keymacro_init(el); 110 (void) map_init(el); 111 if (tty_init(el) == -1) 112 el->el_flags |= NO_TTY; 113 (void) ch_init(el); 114 (void) search_init(el); 115 (void) hist_init(el); 116 (void) prompt_init(el); 117 (void) sig_init(el); 118 (void) literal_init(el); 119 if (read_init(el) == -1) { 120 el_end(el); 121 return NULL; 122 } 123 return el; 124 } 125 126 EditLine * 127 el_init_fd(const char *prog, FILE *fin, FILE *fout, FILE *ferr, 128 int fdin, int fdout, int fderr) 129 { 130 return el_init_internal(prog, fin, fout, ferr, fdin, fdout, fderr, 0); 131 } 132 133 /* el_end(): 134 * Clean up. 135 */ 136 void 137 el_end(EditLine *el) 138 { 139 140 if (el == NULL) 141 return; 142 143 el_reset(el); 144 145 terminal_end(el); 146 keymacro_end(el); 147 map_end(el); 148 if (!(el->el_flags & NO_TTY)) 149 tty_end(el, TCSAFLUSH); 150 ch_end(el); 151 read_end(el); 152 search_end(el); 153 hist_end(el); 154 prompt_end(el); 155 sig_end(el); 156 literal_end(el); 157 158 el_free(el->el_prog); 159 el_free(el->el_visual.cbuff); 160 el_free(el->el_visual.wbuff); 161 el_free(el->el_scratch.cbuff); 162 el_free(el->el_scratch.wbuff); 163 el_free(el->el_lgcyconv.cbuff); 164 el_free(el->el_lgcyconv.wbuff); 165 el_free(el); 166 } 167 168 169 /* el_reset(): 170 * Reset the tty and the parser 171 */ 172 void 173 el_reset(EditLine *el) 174 { 175 176 tty_cookedmode(el); 177 el->el_refresh.r_error = 0; 178 ch_reset(el); /* XXX: Do we want that? */ 179 } 180 181 182 /* el_set(): 183 * set the editline parameters 184 */ 185 int 186 el_wset(EditLine *el, int op, ...) 187 { 188 va_list ap; 189 int rv = 0; 190 191 if (el == NULL) 192 return -1; 193 va_start(ap, op); 194 195 switch (op) { 196 case EL_PROMPT: 197 case EL_RPROMPT: { 198 el_pfunc_t p = va_arg(ap, el_pfunc_t); 199 200 rv = prompt_set(el, p, 0, op, 1); 201 break; 202 } 203 204 case EL_RESIZE: { 205 el_zfunc_t p = va_arg(ap, el_zfunc_t); 206 void *arg = va_arg(ap, void *); 207 rv = ch_resizefun(el, p, arg); 208 break; 209 } 210 211 case EL_ALIAS_TEXT: { 212 el_afunc_t p = va_arg(ap, el_afunc_t); 213 void *arg = va_arg(ap, void *); 214 rv = ch_aliasfun(el, p, arg); 215 break; 216 } 217 218 case EL_PROMPT_ESC: 219 case EL_RPROMPT_ESC: { 220 el_pfunc_t p = va_arg(ap, el_pfunc_t); 221 int c = va_arg(ap, int); 222 223 rv = prompt_set(el, p, (wchar_t)c, op, 1); 224 break; 225 } 226 227 case EL_TERMINAL: 228 rv = terminal_set(el, va_arg(ap, char *)); 229 break; 230 231 case EL_EDITOR: 232 rv = map_set_editor(el, va_arg(ap, wchar_t *)); 233 break; 234 235 case EL_SIGNAL: 236 if (va_arg(ap, int)) 237 el->el_flags |= HANDLE_SIGNALS; 238 else 239 el->el_flags &= ~HANDLE_SIGNALS; 240 break; 241 242 case EL_BIND: 243 case EL_TELLTC: 244 case EL_SETTC: 245 case EL_ECHOTC: 246 case EL_SETTY: 247 { 248 const wchar_t *argv[20]; 249 int i; 250 251 for (i = 1; i < (int)__arraycount(argv); i++) 252 if ((argv[i] = va_arg(ap, wchar_t *)) == NULL) 253 break; 254 255 switch (op) { 256 case EL_BIND: 257 argv[0] = L"bind"; 258 rv = map_bind(el, i, argv); 259 break; 260 261 case EL_TELLTC: 262 argv[0] = L"telltc"; 263 rv = terminal_telltc(el, i, argv); 264 break; 265 266 case EL_SETTC: 267 argv[0] = L"settc"; 268 rv = terminal_settc(el, i, argv); 269 break; 270 271 case EL_ECHOTC: 272 argv[0] = L"echotc"; 273 rv = terminal_echotc(el, i, argv); 274 break; 275 276 case EL_SETTY: 277 argv[0] = L"setty"; 278 rv = tty_stty(el, i, argv); 279 break; 280 281 default: 282 rv = -1; 283 EL_ABORT((el->el_errfile, "Bad op %d\n", op)); 284 } 285 break; 286 } 287 288 case EL_ADDFN: 289 { 290 wchar_t *name = va_arg(ap, wchar_t *); 291 wchar_t *help = va_arg(ap, wchar_t *); 292 el_func_t func = va_arg(ap, el_func_t); 293 294 rv = map_addfunc(el, name, help, func); 295 break; 296 } 297 298 case EL_HIST: 299 { 300 hist_fun_t func = va_arg(ap, hist_fun_t); 301 void *ptr = va_arg(ap, void *); 302 303 rv = hist_set(el, func, ptr); 304 if (MB_CUR_MAX == 1) 305 el->el_flags &= ~NARROW_HISTORY; 306 break; 307 } 308 309 case EL_SAFEREAD: 310 if (va_arg(ap, int)) 311 el->el_flags |= FIXIO; 312 else 313 el->el_flags &= ~FIXIO; 314 rv = 0; 315 break; 316 317 case EL_EDITMODE: 318 if (va_arg(ap, int)) 319 el->el_flags &= ~EDIT_DISABLED; 320 else 321 el->el_flags |= EDIT_DISABLED; 322 rv = 0; 323 break; 324 325 case EL_GETCFN: 326 { 327 el_rfunc_t rc = va_arg(ap, el_rfunc_t); 328 rv = el_read_setfn(el->el_read, rc); 329 break; 330 } 331 332 case EL_CLIENTDATA: 333 el->el_data = va_arg(ap, void *); 334 break; 335 336 case EL_UNBUFFERED: 337 rv = va_arg(ap, int); 338 if (rv && !(el->el_flags & UNBUFFERED)) { 339 el->el_flags |= UNBUFFERED; 340 read_prepare(el); 341 if (el->el_refresh.r_error) { 342 rv = -1; 343 break; 344 } 345 } else if (!rv && (el->el_flags & UNBUFFERED)) { 346 el->el_flags &= ~UNBUFFERED; 347 read_finish(el); 348 } 349 rv = 0; 350 break; 351 352 case EL_PREP_TERM: 353 rv = va_arg(ap, int); 354 if (rv) 355 (void) tty_rawmode(el); 356 else 357 (void) tty_cookedmode(el); 358 rv = 0; 359 break; 360 361 case EL_SETFP: 362 { 363 FILE *fp; 364 int what; 365 366 what = va_arg(ap, int); 367 fp = va_arg(ap, FILE *); 368 369 rv = 0; 370 switch (what) { 371 case 0: 372 el->el_infile = fp; 373 el->el_infd = fileno(fp); 374 break; 375 case 1: 376 el->el_outfile = fp; 377 el->el_outfd = fileno(fp); 378 break; 379 case 2: 380 el->el_errfile = fp; 381 el->el_errfd = fileno(fp); 382 break; 383 default: 384 rv = -1; 385 break; 386 } 387 break; 388 } 389 390 case EL_REFRESH: 391 el->el_refresh.r_error = 0; 392 re_clear_display(el); 393 re_refresh(el); 394 terminal__flush(el); 395 if (el->el_refresh.r_error) 396 rv = -1; 397 break; 398 399 case EL_WORDCHARS: 400 rv = map_set_wordchars(el, va_arg(ap, wchar_t *)); 401 break; 402 403 case EL_GETENV: 404 el->el_getenv = va_arg(ap, func_t); 405 break; 406 407 case EL_MATCH_HIDDEN_FILES: 408 if (va_arg(ap, int)) 409 el->el_flags |= MATCH_HIDDEN_FILES; 410 else 411 el->el_flags &= ~MATCH_HIDDEN_FILES; 412 break; 413 414 default: 415 rv = -1; 416 break; 417 } 418 419 va_end(ap); 420 return rv; 421 } 422 423 424 /* el_get(): 425 * retrieve the editline parameters 426 */ 427 int 428 el_wget(EditLine *el, int op, ...) 429 { 430 va_list ap; 431 int rv; 432 433 if (el == NULL) 434 return -1; 435 436 va_start(ap, op); 437 438 switch (op) { 439 case EL_PROMPT: 440 case EL_RPROMPT: { 441 el_pfunc_t *p = va_arg(ap, el_pfunc_t *); 442 rv = prompt_get(el, p, 0, op); 443 break; 444 } 445 case EL_PROMPT_ESC: 446 case EL_RPROMPT_ESC: { 447 el_pfunc_t *p = va_arg(ap, el_pfunc_t *); 448 wchar_t *c = va_arg(ap, wchar_t *); 449 450 rv = prompt_get(el, p, c, op); 451 break; 452 } 453 454 case EL_EDITOR: 455 rv = map_get_editor(el, va_arg(ap, const wchar_t **)); 456 break; 457 458 case EL_SIGNAL: 459 *va_arg(ap, int *) = (el->el_flags & HANDLE_SIGNALS); 460 rv = 0; 461 break; 462 463 case EL_EDITMODE: 464 *va_arg(ap, int *) = !(el->el_flags & EDIT_DISABLED); 465 rv = 0; 466 break; 467 468 case EL_SAFEREAD: 469 *va_arg(ap, int *) = (el->el_flags & FIXIO); 470 rv = 0; 471 break; 472 473 case EL_TERMINAL: 474 terminal_get(el, va_arg(ap, const char **)); 475 rv = 0; 476 break; 477 478 case EL_GETTC: 479 { 480 static char name[] = "gettc"; 481 char *argv[3]; 482 argv[0] = name; 483 argv[1] = va_arg(ap, char *); 484 argv[2] = va_arg(ap, void *); 485 rv = terminal_gettc(el, 3, argv); 486 break; 487 } 488 489 case EL_GETCFN: 490 *va_arg(ap, el_rfunc_t *) = el_read_getfn(el->el_read); 491 rv = 0; 492 break; 493 494 case EL_CLIENTDATA: 495 *va_arg(ap, void **) = el->el_data; 496 rv = 0; 497 break; 498 499 case EL_UNBUFFERED: 500 *va_arg(ap, int *) = (el->el_flags & UNBUFFERED) != 0; 501 rv = 0; 502 break; 503 504 case EL_GETFP: 505 { 506 int what; 507 FILE **fpp; 508 509 what = va_arg(ap, int); 510 fpp = va_arg(ap, FILE **); 511 rv = 0; 512 switch (what) { 513 case 0: 514 *fpp = el->el_infile; 515 break; 516 case 1: 517 *fpp = el->el_outfile; 518 break; 519 case 2: 520 *fpp = el->el_errfile; 521 break; 522 default: 523 rv = -1; 524 break; 525 } 526 break; 527 } 528 529 case EL_WORDCHARS: 530 rv = map_get_wordchars(el, va_arg(ap, const wchar_t **)); 531 break; 532 533 case EL_GETENV: 534 *va_arg(ap, func_t *) = el->el_getenv; 535 rv = 0; 536 break; 537 538 case EL_MATCH_HIDDEN_FILES: 539 *va_arg(ap, int *) = el->el_flags & MATCH_HIDDEN_FILES ? 1 : 0; 540 rv = 0; 541 break; 542 543 default: 544 rv = -1; 545 break; 546 } 547 va_end(ap); 548 549 return rv; 550 } 551 552 553 /* el_line(): 554 * Return editing info 555 */ 556 const LineInfoW * 557 el_wline(EditLine *el) 558 { 559 560 return (const LineInfoW *)(void *)&el->el_line; 561 } 562 563 564 /* el_source(): 565 * Source a file 566 */ 567 int 568 el_source(EditLine *el, const char *fname) 569 { 570 FILE *fp; 571 size_t len; 572 ssize_t slen; 573 char *ptr; 574 char *path = NULL; 575 const wchar_t *dptr; 576 int error = 0; 577 578 fp = NULL; 579 if (fname == NULL) { 580 #ifdef HAVE_ISSETUGID 581 if (issetugid()) 582 return -1; 583 584 if ((fname = (el->el_getenv)("EDITRC")) == NULL) { 585 static const char elpath[] = "/.editrc"; 586 size_t plen = sizeof(elpath); 587 588 if ((ptr = (el->el_getenv)("HOME")) == NULL) 589 return -1; 590 plen += strlen(ptr); 591 if ((path = el_calloc(plen, sizeof(*path))) == NULL) 592 return -1; 593 (void)snprintf(path, plen, "%s%s", ptr, 594 elpath + (*ptr == '\0')); 595 fname = path; 596 } 597 #else 598 /* 599 * If issetugid() is missing, always return an error, in order 600 * to keep from inadvertently opening up the user to a security 601 * hole. 602 */ 603 return -1; 604 #endif 605 } 606 if (fname[0] == '\0') 607 return -1; 608 609 if (fp == NULL) 610 fp = fopen(fname, "r"); 611 if (fp == NULL) { 612 el_free(path); 613 return -1; 614 } 615 616 ptr = NULL; 617 len = 0; 618 while ((slen = getline(&ptr, &len, fp)) != -1) { 619 if (*ptr == '\n') 620 continue; /* Empty line. */ 621 if (slen > 0 && ptr[--slen] == '\n') 622 ptr[slen] = '\0'; 623 624 dptr = ct_decode_string(ptr, &el->el_scratch); 625 if (!dptr) 626 continue; 627 /* loop until first non-space char or EOL */ 628 while (*dptr != '\0' && iswspace(*dptr)) 629 dptr++; 630 if (*dptr == '#') 631 continue; /* ignore, this is a comment line */ 632 if ((error = parse_line(el, dptr)) == -1) 633 break; 634 } 635 free(ptr); 636 637 el_free(path); 638 (void) fclose(fp); 639 return error; 640 } 641 642 643 /* el_resize(): 644 * Called from program when terminal is resized 645 */ 646 void 647 el_resize(EditLine *el) 648 { 649 int lins, cols; 650 sigset_t oset, nset; 651 652 (void) sigemptyset(&nset); 653 (void) sigaddset(&nset, SIGWINCH); 654 (void) sigprocmask(SIG_BLOCK, &nset, &oset); 655 656 /* get the correct window size */ 657 if (terminal_get_size(el, &lins, &cols)) 658 terminal_change_size(el, lins, cols); 659 660 (void) sigprocmask(SIG_SETMASK, &oset, NULL); 661 } 662 663 664 /* el_beep(): 665 * Called from the program to beep 666 */ 667 void 668 el_beep(EditLine *el) 669 { 670 671 terminal_beep(el); 672 } 673 674 675 /* el_editmode() 676 * Set the state of EDIT_DISABLED from the `edit' command. 677 */ 678 libedit_private int 679 /*ARGSUSED*/ 680 el_editmode(EditLine *el, int argc, const wchar_t **argv) 681 { 682 const wchar_t *how; 683 684 if (argv == NULL || argc != 2 || argv[1] == NULL) 685 return -1; 686 687 how = argv[1]; 688 if (wcscmp(how, L"on") == 0) { 689 el->el_flags &= ~EDIT_DISABLED; 690 tty_rawmode(el); 691 } else if (wcscmp(how, L"off") == 0) { 692 tty_cookedmode(el); 693 el->el_flags |= EDIT_DISABLED; 694 } 695 else { 696 (void) fprintf(el->el_errfile, "edit: Bad value `%ls'.\n", 697 how); 698 return -1; 699 } 700 return 0; 701 } 702