1 /* $NetBSD: el.c,v 1.105 2026/08/15 10:12:49 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.105 2026/08/15 10:12:49 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_prog); 104 el_free(el); 105 return NULL; 106 } 107 (void) keymacro_init(el); 108 (void) map_init(el); 109 if (tty_init(el) == -1) 110 el->el_flags |= NO_TTY; 111 (void) ch_init(el); 112 (void) search_init(el); 113 (void) hist_init(el); 114 (void) prompt_init(el); 115 (void) sig_init(el); 116 (void) literal_init(el); 117 if (read_init(el) == -1) { 118 el_end(el); 119 return NULL; 120 } 121 return el; 122 } 123 124 EditLine * 125 el_init_fd(const char *prog, FILE *fin, FILE *fout, FILE *ferr, 126 int fdin, int fdout, int fderr) 127 { 128 return el_init_internal(prog, fin, fout, ferr, fdin, fdout, fderr, 0); 129 } 130 131 /* el_end(): 132 * Clean up. 133 */ 134 void 135 el_end(EditLine *el) 136 { 137 138 if (el == NULL) 139 return; 140 141 el_reset(el); 142 143 terminal_end(el); 144 keymacro_end(el); 145 map_end(el); 146 if (!(el->el_flags & NO_TTY)) 147 tty_end(el, TCSAFLUSH); 148 ch_end(el); 149 read_end(el); 150 search_end(el); 151 hist_end(el); 152 prompt_end(el); 153 sig_end(el); 154 literal_end(el); 155 156 el_free(el->el_prog); 157 el_free(el->el_visual.cbuff); 158 el_free(el->el_visual.wbuff); 159 el_free(el->el_scratch.cbuff); 160 el_free(el->el_scratch.wbuff); 161 el_free(el->el_lgcyconv.cbuff); 162 el_free(el->el_lgcyconv.wbuff); 163 el_free(el); 164 } 165 166 167 /* el_reset(): 168 * Reset the tty and the parser 169 */ 170 void 171 el_reset(EditLine *el) 172 { 173 174 tty_cookedmode(el); 175 ch_reset(el); /* XXX: Do we want that? */ 176 } 177 178 179 /* el_set(): 180 * set the editline parameters 181 */ 182 int 183 el_wset(EditLine *el, int op, ...) 184 { 185 va_list ap; 186 int rv = 0; 187 188 if (el == NULL) 189 return -1; 190 va_start(ap, op); 191 192 switch (op) { 193 case EL_PROMPT: 194 case EL_RPROMPT: { 195 el_pfunc_t p = va_arg(ap, el_pfunc_t); 196 197 rv = prompt_set(el, p, 0, op, 1); 198 break; 199 } 200 201 case EL_RESIZE: { 202 el_zfunc_t p = va_arg(ap, el_zfunc_t); 203 void *arg = va_arg(ap, void *); 204 rv = ch_resizefun(el, p, arg); 205 break; 206 } 207 208 case EL_ALIAS_TEXT: { 209 el_afunc_t p = va_arg(ap, el_afunc_t); 210 void *arg = va_arg(ap, void *); 211 rv = ch_aliasfun(el, p, arg); 212 break; 213 } 214 215 case EL_PROMPT_ESC: 216 case EL_RPROMPT_ESC: { 217 el_pfunc_t p = va_arg(ap, el_pfunc_t); 218 int c = va_arg(ap, int); 219 220 rv = prompt_set(el, p, (wchar_t)c, op, 1); 221 break; 222 } 223 224 case EL_TERMINAL: 225 rv = terminal_set(el, va_arg(ap, char *)); 226 break; 227 228 case EL_EDITOR: 229 rv = map_set_editor(el, va_arg(ap, wchar_t *)); 230 break; 231 232 case EL_SIGNAL: 233 if (va_arg(ap, int)) 234 el->el_flags |= HANDLE_SIGNALS; 235 else 236 el->el_flags &= ~HANDLE_SIGNALS; 237 break; 238 239 case EL_BIND: 240 case EL_TELLTC: 241 case EL_SETTC: 242 case EL_ECHOTC: 243 case EL_SETTY: 244 { 245 const wchar_t *argv[20]; 246 int i; 247 248 for (i = 1; i < (int)__arraycount(argv); i++) 249 if ((argv[i] = va_arg(ap, wchar_t *)) == NULL) 250 break; 251 252 switch (op) { 253 case EL_BIND: 254 argv[0] = L"bind"; 255 rv = map_bind(el, i, argv); 256 break; 257 258 case EL_TELLTC: 259 argv[0] = L"telltc"; 260 rv = terminal_telltc(el, i, argv); 261 break; 262 263 case EL_SETTC: 264 argv[0] = L"settc"; 265 rv = terminal_settc(el, i, argv); 266 break; 267 268 case EL_ECHOTC: 269 argv[0] = L"echotc"; 270 rv = terminal_echotc(el, i, argv); 271 break; 272 273 case EL_SETTY: 274 argv[0] = L"setty"; 275 rv = tty_stty(el, i, argv); 276 break; 277 278 default: 279 rv = -1; 280 EL_ABORT((el->el_errfile, "Bad op %d\n", op)); 281 } 282 break; 283 } 284 285 case EL_ADDFN: 286 { 287 wchar_t *name = va_arg(ap, wchar_t *); 288 wchar_t *help = va_arg(ap, wchar_t *); 289 el_func_t func = va_arg(ap, el_func_t); 290 291 rv = map_addfunc(el, name, help, func); 292 break; 293 } 294 295 case EL_HIST: 296 { 297 hist_fun_t func = va_arg(ap, hist_fun_t); 298 void *ptr = va_arg(ap, void *); 299 300 rv = hist_set(el, func, ptr); 301 if (MB_CUR_MAX == 1) 302 el->el_flags &= ~NARROW_HISTORY; 303 break; 304 } 305 306 case EL_SAFEREAD: 307 if (va_arg(ap, int)) 308 el->el_flags |= FIXIO; 309 else 310 el->el_flags &= ~FIXIO; 311 rv = 0; 312 break; 313 314 case EL_EDITMODE: 315 if (va_arg(ap, int)) 316 el->el_flags &= ~EDIT_DISABLED; 317 else 318 el->el_flags |= EDIT_DISABLED; 319 rv = 0; 320 break; 321 322 case EL_GETCFN: 323 { 324 el_rfunc_t rc = va_arg(ap, el_rfunc_t); 325 rv = el_read_setfn(el->el_read, rc); 326 break; 327 } 328 329 case EL_CLIENTDATA: 330 el->el_data = va_arg(ap, void *); 331 break; 332 333 case EL_UNBUFFERED: 334 rv = va_arg(ap, int); 335 if (rv && !(el->el_flags & UNBUFFERED)) { 336 el->el_flags |= UNBUFFERED; 337 read_prepare(el); 338 } else if (!rv && (el->el_flags & UNBUFFERED)) { 339 el->el_flags &= ~UNBUFFERED; 340 read_finish(el); 341 } 342 rv = 0; 343 break; 344 345 case EL_PREP_TERM: 346 rv = va_arg(ap, int); 347 if (rv) 348 (void) tty_rawmode(el); 349 else 350 (void) tty_cookedmode(el); 351 rv = 0; 352 break; 353 354 case EL_SETFP: 355 { 356 FILE *fp; 357 int what; 358 359 what = va_arg(ap, int); 360 fp = va_arg(ap, FILE *); 361 362 rv = 0; 363 switch (what) { 364 case 0: 365 el->el_infile = fp; 366 el->el_infd = fileno(fp); 367 break; 368 case 1: 369 el->el_outfile = fp; 370 el->el_outfd = fileno(fp); 371 break; 372 case 2: 373 el->el_errfile = fp; 374 el->el_errfd = fileno(fp); 375 break; 376 default: 377 rv = -1; 378 break; 379 } 380 break; 381 } 382 383 case EL_REFRESH: 384 re_clear_display(el); 385 re_refresh(el); 386 terminal__flush(el); 387 break; 388 389 case EL_WORDCHARS: 390 rv = map_set_wordchars(el, va_arg(ap, wchar_t *)); 391 break; 392 393 case EL_GETENV: 394 el->el_getenv = va_arg(ap, func_t); 395 break; 396 397 case EL_MATCH_HIDDEN_FILES: 398 if (va_arg(ap, int)) 399 el->el_flags |= MATCH_HIDDEN_FILES; 400 else 401 el->el_flags &= ~MATCH_HIDDEN_FILES; 402 break; 403 404 default: 405 rv = -1; 406 break; 407 } 408 409 va_end(ap); 410 return rv; 411 } 412 413 414 /* el_get(): 415 * retrieve the editline parameters 416 */ 417 int 418 el_wget(EditLine *el, int op, ...) 419 { 420 va_list ap; 421 int rv; 422 423 if (el == NULL) 424 return -1; 425 426 va_start(ap, op); 427 428 switch (op) { 429 case EL_PROMPT: 430 case EL_RPROMPT: { 431 el_pfunc_t *p = va_arg(ap, el_pfunc_t *); 432 rv = prompt_get(el, p, 0, op); 433 break; 434 } 435 case EL_PROMPT_ESC: 436 case EL_RPROMPT_ESC: { 437 el_pfunc_t *p = va_arg(ap, el_pfunc_t *); 438 wchar_t *c = va_arg(ap, wchar_t *); 439 440 rv = prompt_get(el, p, c, op); 441 break; 442 } 443 444 case EL_EDITOR: 445 rv = map_get_editor(el, va_arg(ap, const wchar_t **)); 446 break; 447 448 case EL_SIGNAL: 449 *va_arg(ap, int *) = (el->el_flags & HANDLE_SIGNALS); 450 rv = 0; 451 break; 452 453 case EL_EDITMODE: 454 *va_arg(ap, int *) = !(el->el_flags & EDIT_DISABLED); 455 rv = 0; 456 break; 457 458 case EL_SAFEREAD: 459 *va_arg(ap, int *) = (el->el_flags & FIXIO); 460 rv = 0; 461 break; 462 463 case EL_TERMINAL: 464 terminal_get(el, va_arg(ap, const char **)); 465 rv = 0; 466 break; 467 468 case EL_GETTC: 469 { 470 static char name[] = "gettc"; 471 char *argv[3]; 472 argv[0] = name; 473 argv[1] = va_arg(ap, char *); 474 argv[2] = va_arg(ap, void *); 475 rv = terminal_gettc(el, 3, argv); 476 break; 477 } 478 479 case EL_GETCFN: 480 *va_arg(ap, el_rfunc_t *) = el_read_getfn(el->el_read); 481 rv = 0; 482 break; 483 484 case EL_CLIENTDATA: 485 *va_arg(ap, void **) = el->el_data; 486 rv = 0; 487 break; 488 489 case EL_UNBUFFERED: 490 *va_arg(ap, int *) = (el->el_flags & UNBUFFERED) != 0; 491 rv = 0; 492 break; 493 494 case EL_GETFP: 495 { 496 int what; 497 FILE **fpp; 498 499 what = va_arg(ap, int); 500 fpp = va_arg(ap, FILE **); 501 rv = 0; 502 switch (what) { 503 case 0: 504 *fpp = el->el_infile; 505 break; 506 case 1: 507 *fpp = el->el_outfile; 508 break; 509 case 2: 510 *fpp = el->el_errfile; 511 break; 512 default: 513 rv = -1; 514 break; 515 } 516 break; 517 } 518 519 case EL_WORDCHARS: 520 rv = map_get_wordchars(el, va_arg(ap, const wchar_t **)); 521 break; 522 523 case EL_GETENV: 524 *va_arg(ap, func_t *) = el->el_getenv; 525 rv = 0; 526 break; 527 528 case EL_MATCH_HIDDEN_FILES: 529 *va_arg(ap, int *) = el->el_flags & MATCH_HIDDEN_FILES ? 1 : 0; 530 rv = 0; 531 break; 532 533 default: 534 rv = -1; 535 break; 536 } 537 va_end(ap); 538 539 return rv; 540 } 541 542 543 /* el_line(): 544 * Return editing info 545 */ 546 const LineInfoW * 547 el_wline(EditLine *el) 548 { 549 550 return (const LineInfoW *)(void *)&el->el_line; 551 } 552 553 554 /* el_source(): 555 * Source a file 556 */ 557 int 558 el_source(EditLine *el, const char *fname) 559 { 560 FILE *fp; 561 size_t len; 562 ssize_t slen; 563 char *ptr; 564 char *path = NULL; 565 const wchar_t *dptr; 566 int error = 0; 567 568 fp = NULL; 569 if (fname == NULL) { 570 #ifdef HAVE_ISSETUGID 571 if (issetugid()) 572 return -1; 573 574 if ((fname = (el->el_getenv)("EDITRC")) == NULL) { 575 static const char elpath[] = "/.editrc"; 576 size_t plen = sizeof(elpath); 577 578 if ((ptr = (el->el_getenv)("HOME")) == NULL) 579 return -1; 580 plen += strlen(ptr); 581 if ((path = el_calloc(plen, sizeof(*path))) == NULL) 582 return -1; 583 (void)snprintf(path, plen, "%s%s", ptr, 584 elpath + (*ptr == '\0')); 585 fname = path; 586 } 587 #else 588 /* 589 * If issetugid() is missing, always return an error, in order 590 * to keep from inadvertently opening up the user to a security 591 * hole. 592 */ 593 return -1; 594 #endif 595 } 596 if (fname[0] == '\0') 597 return -1; 598 599 if (fp == NULL) 600 fp = fopen(fname, "r"); 601 if (fp == NULL) { 602 el_free(path); 603 return -1; 604 } 605 606 ptr = NULL; 607 len = 0; 608 while ((slen = getline(&ptr, &len, fp)) != -1) { 609 if (*ptr == '\n') 610 continue; /* Empty line. */ 611 if (slen > 0 && ptr[--slen] == '\n') 612 ptr[slen] = '\0'; 613 614 dptr = ct_decode_string(ptr, &el->el_scratch); 615 if (!dptr) 616 continue; 617 /* loop until first non-space char or EOL */ 618 while (*dptr != '\0' && iswspace(*dptr)) 619 dptr++; 620 if (*dptr == '#') 621 continue; /* ignore, this is a comment line */ 622 if ((error = parse_line(el, dptr)) == -1) 623 break; 624 } 625 free(ptr); 626 627 el_free(path); 628 (void) fclose(fp); 629 return error; 630 } 631 632 633 /* el_resize(): 634 * Called from program when terminal is resized 635 */ 636 void 637 el_resize(EditLine *el) 638 { 639 int lins, cols; 640 sigset_t oset, nset; 641 642 (void) sigemptyset(&nset); 643 (void) sigaddset(&nset, SIGWINCH); 644 (void) sigprocmask(SIG_BLOCK, &nset, &oset); 645 646 /* get the correct window size */ 647 if (terminal_get_size(el, &lins, &cols)) 648 terminal_change_size(el, lins, cols); 649 650 (void) sigprocmask(SIG_SETMASK, &oset, NULL); 651 } 652 653 654 /* el_beep(): 655 * Called from the program to beep 656 */ 657 void 658 el_beep(EditLine *el) 659 { 660 661 terminal_beep(el); 662 } 663 664 665 /* el_editmode() 666 * Set the state of EDIT_DISABLED from the `edit' command. 667 */ 668 libedit_private int 669 /*ARGSUSED*/ 670 el_editmode(EditLine *el, int argc, const wchar_t **argv) 671 { 672 const wchar_t *how; 673 674 if (argv == NULL || argc != 2 || argv[1] == NULL) 675 return -1; 676 677 how = argv[1]; 678 if (wcscmp(how, L"on") == 0) { 679 el->el_flags &= ~EDIT_DISABLED; 680 tty_rawmode(el); 681 } else if (wcscmp(how, L"off") == 0) { 682 tty_cookedmode(el); 683 el->el_flags |= EDIT_DISABLED; 684 } 685 else { 686 (void) fprintf(el->el_errfile, "edit: Bad value `%ls'.\n", 687 how); 688 return -1; 689 } 690 return 0; 691 } 692
Indexes created Mon Oct 05 00:25:34 UTC 2026