1 /* $NetBSD: el.c,v 1.61 2011/01/27 23:11:40 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.61 2011/01/27 23:11:40 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 <string.h> 50 #include <stdlib.h> 51 #include <stdarg.h> 52 #include <ctype.h> 53 #include <locale.h> 54 #include <langinfo.h> 55 #include "el.h" 56 57 /* el_init(): 58 * Initialize editline and set default parameters. 59 */ 60 public EditLine * 61 el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr) 62 { 63 EditLine *el = (EditLine *) el_malloc(sizeof(EditLine)); 64 65 if (el == NULL) 66 return (NULL); 67 68 memset(el, 0, sizeof(EditLine)); 69 70 el->el_infile = fin; 71 el->el_outfile = fout; 72 el->el_errfile = ferr; 73 74 el->el_infd = fileno(fin); 75 el->el_outfd = fileno(fout); 76 el->el_errfd = fileno(ferr); 77 78 el->el_prog = Strdup(ct_decode_string(prog, &el->el_scratch)); 79 if (el->el_prog == NULL) { 80 el_free(el); 81 return NULL; 82 } 83 84 /* 85 * Initialize all the modules. Order is important!!! 86 */ 87 el->el_flags = 0; 88 #ifdef WIDECHAR 89 if (setlocale(LC_CTYPE, NULL) != NULL){ 90 if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) 91 el->el_flags |= CHARSET_IS_UTF8; 92 } 93 #endif 94 95 if (term_init(el) == -1) { 96 el_free(el->el_prog); 97 el_free(el); 98 return NULL; 99 } 100 (void) key_init(el); 101 (void) map_init(el); 102 if (tty_init(el) == -1) 103 el->el_flags |= NO_TTY; 104 (void) ch_init(el); 105 (void) search_init(el); 106 (void) hist_init(el); 107 (void) prompt_init(el); 108 (void) sig_init(el); 109 (void) read_init(el); 110 111 return (el); 112 } 113 114 115 /* el_end(): 116 * Clean up. 117 */ 118 public void 119 el_end(EditLine *el) 120 { 121 122 if (el == NULL) 123 return; 124 125 el_reset(el); 126 127 term_end(el); 128 key_end(el); 129 map_end(el); 130 tty_end(el); 131 ch_end(el); 132 search_end(el); 133 hist_end(el); 134 prompt_end(el); 135 sig_end(el); 136 137 el_free((ptr_t) el->el_prog); 138 el_free((ptr_t) el); 139 #ifdef WIDECHAR 140 el_free((ptr_t) el->el_scratch.cbuff); 141 el_free((ptr_t) el->el_scratch.wbuff); 142 el_free((ptr_t) el->el_lgcyconv.cbuff); 143 el_free((ptr_t) el->el_lgcyconv.wbuff); 144 #endif 145 } 146 147 148 /* el_reset(): 149 * Reset the tty and the parser 150 */ 151 public void 152 el_reset(EditLine *el) 153 { 154 155 tty_cookedmode(el); 156 ch_reset(el, 0); /* XXX: Do we want that? */ 157 } 158 159 160 /* el_set(): 161 * set the editline parameters 162 */ 163 public int 164 FUN(el,set)(EditLine *el, int op, ...) 165 { 166 va_list ap; 167 int rv = 0; 168 169 if (el == NULL) 170 return (-1); 171 va_start(ap, op); 172 173 switch (op) { 174 case EL_PROMPT: 175 case EL_RPROMPT: { 176 el_pfunc_t p = va_arg(ap, el_pfunc_t); 177 178 rv = prompt_set(el, p, 0, op, 1); 179 break; 180 } 181 182 case EL_RESIZE: { 183 el_zfunc_t p = va_arg(ap, el_zfunc_t); 184 void *arg = va_arg(ap, void *); 185 rv = ch_resizefun(el, p, arg); 186 break; 187 } 188 189 case EL_PROMPT_ESC: 190 case EL_RPROMPT_ESC: { 191 el_pfunc_t p = va_arg(ap, el_pfunc_t); 192 int c = va_arg(ap, int); 193 194 rv = prompt_set(el, p, c, op, 1); 195 break; 196 } 197 198 case EL_TERMINAL: 199 rv = term_set(el, va_arg(ap, char *)); 200 break; 201 202 case EL_EDITOR: 203 rv = map_set_editor(el, va_arg(ap, Char *)); 204 break; 205 206 case EL_SIGNAL: 207 if (va_arg(ap, int)) 208 el->el_flags |= HANDLE_SIGNALS; 209 else 210 el->el_flags &= ~HANDLE_SIGNALS; 211 break; 212 213 case EL_BIND: 214 case EL_TELLTC: 215 case EL_SETTC: 216 case EL_ECHOTC: 217 case EL_SETTY: 218 { 219 const Char *argv[20]; 220 int i; 221 222 for (i = 1; i < 20; i++) 223 if ((argv[i] = va_arg(ap, Char *)) == NULL) 224 break; 225 226 switch (op) { 227 case EL_BIND: 228 argv[0] = STR("bind"); 229 rv = map_bind(el, i, argv); 230 break; 231 232 case EL_TELLTC: 233 argv[0] = STR("telltc"); 234 rv = term_telltc(el, i, argv); 235 break; 236 237 case EL_SETTC: 238 argv[0] = STR("settc"); 239 rv = term_settc(el, i, argv); 240 break; 241 242 case EL_ECHOTC: 243 argv[0] = STR("echotc"); 244 rv = term_echotc(el, i, argv); 245 break; 246 247 case EL_SETTY: 248 argv[0] = STR("setty"); 249 rv = tty_stty(el, i, argv); 250 break; 251 252 default: 253 rv = -1; 254 EL_ABORT((el->el_errfile, "Bad op %d\n", op)); 255 break; 256 } 257 break; 258 } 259 260 case EL_ADDFN: 261 { 262 Char *name = va_arg(ap, Char *); 263 Char *help = va_arg(ap, Char *); 264 el_func_t func = va_arg(ap, el_func_t); 265 266 rv = map_addfunc(el, name, help, func); 267 break; 268 } 269 270 case EL_HIST: 271 { 272 hist_fun_t func = va_arg(ap, hist_fun_t); 273 ptr_t ptr = va_arg(ap, ptr_t); 274 275 rv = hist_set(el, func, ptr); 276 if (!(el->el_flags & CHARSET_IS_UTF8)) 277 el->el_flags &= ~NARROW_HISTORY; 278 break; 279 } 280 281 case EL_EDITMODE: 282 if (va_arg(ap, int)) 283 el->el_flags &= ~EDIT_DISABLED; 284 else 285 el->el_flags |= EDIT_DISABLED; 286 rv = 0; 287 break; 288 289 case EL_GETCFN: 290 { 291 el_rfunc_t rc = va_arg(ap, el_rfunc_t); 292 rv = el_read_setfn(el, rc); 293 el->el_flags &= ~NARROW_READ; 294 break; 295 } 296 297 case EL_CLIENTDATA: 298 el->el_data = va_arg(ap, void *); 299 break; 300 301 case EL_UNBUFFERED: 302 rv = va_arg(ap, int); 303 if (rv && !(el->el_flags & UNBUFFERED)) { 304 el->el_flags |= UNBUFFERED; 305 read_prepare(el); 306 } else if (!rv && (el->el_flags & UNBUFFERED)) { 307 el->el_flags &= ~UNBUFFERED; 308 read_finish(el); 309 } 310 rv = 0; 311 break; 312 313 case EL_PREP_TERM: 314 rv = va_arg(ap, int); 315 if (rv) 316 (void) tty_rawmode(el); 317 else 318 (void) tty_cookedmode(el); 319 rv = 0; 320 break; 321 322 case EL_SETFP: 323 { 324 FILE *fp; 325 int what; 326 327 what = va_arg(ap, int); 328 fp = va_arg(ap, FILE *); 329 330 rv = 0; 331 switch (what) { 332 case 0: 333 el->el_infile = fp; 334 el->el_infd = fileno(fp); 335 break; 336 case 1: 337 el->el_outfile = fp; 338 el->el_outfd = fileno(fp); 339 break; 340 case 2: 341 el->el_errfile = fp; 342 el->el_errfd = fileno(fp); 343 break; 344 default: 345 rv = -1; 346 break; 347 } 348 break; 349 } 350 351 case EL_REFRESH: 352 re_clear_display(el); 353 re_refresh(el); 354 term__flush(el); 355 break; 356 357 default: 358 rv = -1; 359 break; 360 } 361 362 va_end(ap); 363 return (rv); 364 } 365 366 367 /* el_get(): 368 * retrieve the editline parameters 369 */ 370 public int 371 FUN(el,get)(EditLine *el, int op, ...) 372 { 373 va_list ap; 374 int rv; 375 376 if (el == NULL) 377 return -1; 378 379 va_start(ap, op); 380 381 switch (op) { 382 case EL_PROMPT: 383 case EL_RPROMPT: { 384 el_pfunc_t *p = va_arg(ap, el_pfunc_t *); 385 rv = prompt_get(el, p, 0, op); 386 break; 387 } 388 case EL_PROMPT_ESC: 389 case EL_RPROMPT_ESC: { 390 el_pfunc_t *p = va_arg(ap, el_pfunc_t *); 391 Char *c = va_arg(ap, Char *); 392 393 rv = prompt_get(el, p, c, op); 394 break; 395 } 396 397 case EL_EDITOR: 398 rv = map_get_editor(el, va_arg(ap, const Char **)); 399 break; 400 401 case EL_SIGNAL: 402 *va_arg(ap, int *) = (el->el_flags & HANDLE_SIGNALS); 403 rv = 0; 404 break; 405 406 case EL_EDITMODE: 407 *va_arg(ap, int *) = !(el->el_flags & EDIT_DISABLED); 408 rv = 0; 409 break; 410 411 case EL_TERMINAL: 412 term_get(el, va_arg(ap, const char **)); 413 rv = 0; 414 break; 415 416 case EL_GETTC: 417 { 418 static char name[] = "gettc"; 419 char *argv[20]; 420 int i; 421 422 for (i = 1; i < (int)(sizeof(argv) / sizeof(argv[0])); i++) 423 if ((argv[i] = va_arg(ap, char *)) == NULL) 424 break; 425 426 switch (op) { 427 case EL_GETTC: 428 argv[0] = name; 429 rv = term_gettc(el, i, argv); 430 break; 431 432 default: 433 rv = -1; 434 EL_ABORT((el->el_errfile, "Bad op %d\n", op)); 435 break; 436 } 437 break; 438 } 439 440 case EL_GETCFN: 441 *va_arg(ap, el_rfunc_t *) = el_read_getfn(el); 442 rv = 0; 443 break; 444 445 case EL_CLIENTDATA: 446 *va_arg(ap, void **) = el->el_data; 447 rv = 0; 448 break; 449 450 case EL_UNBUFFERED: 451 *va_arg(ap, int *) = (!(el->el_flags & UNBUFFERED)); 452 rv = 0; 453 break; 454 455 case EL_GETFP: 456 { 457 int what; 458 FILE **fpp; 459 460 what = va_arg(ap, int); 461 fpp = va_arg(ap, FILE **); 462 rv = 0; 463 switch (what) { 464 case 0: 465 *fpp = el->el_infile; 466 break; 467 case 1: 468 *fpp = el->el_outfile; 469 break; 470 case 2: 471 *fpp = el->el_errfile; 472 break; 473 default: 474 rv = -1; 475 break; 476 } 477 break; 478 } 479 default: 480 rv = -1; 481 break; 482 } 483 va_end(ap); 484 485 return (rv); 486 } 487 488 489 /* el_line(): 490 * Return editing info 491 */ 492 public const TYPE(LineInfo) * 493 FUN(el,line)(EditLine *el) 494 { 495 496 return (const TYPE(LineInfo) *) (void *) &el->el_line; 497 } 498 499 500 /* el_source(): 501 * Source a file 502 */ 503 public int 504 el_source(EditLine *el, const char *fname) 505 { 506 FILE *fp; 507 size_t len; 508 char *ptr; 509 #ifdef HAVE_ISSETUGID 510 char path[MAXPATHLEN]; 511 #endif 512 const Char *dptr; 513 514 fp = NULL; 515 if (fname == NULL) { 516 #ifdef HAVE_ISSETUGID 517 static const char elpath[] = "/.editrc"; 518 519 if (issetugid()) 520 return (-1); 521 if ((ptr = getenv("HOME")) == NULL) 522 return (-1); 523 if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path)) 524 return (-1); 525 if (strlcat(path, elpath, sizeof(path)) >= sizeof(path)) 526 return (-1); 527 fname = path; 528 #else 529 /* 530 * If issetugid() is missing, always return an error, in order 531 * to keep from inadvertently opening up the user to a security 532 * hole. 533 */ 534 return (-1); 535 #endif 536 } 537 if (fp == NULL) 538 fp = fopen(fname, "r"); 539 if (fp == NULL) 540 return (-1); 541 542 while ((ptr = fgetln(fp, &len)) != NULL) { 543 dptr = ct_decode_string(ptr, &el->el_scratch); 544 if (!dptr) 545 continue; 546 if (len > 0 && dptr[len - 1] == '\n') 547 --len; 548 549 /* loop until first non-space char or EOL */ 550 while (*dptr != '\0' && Isspace(*dptr)) 551 dptr++; 552 if (*dptr == '#') 553 continue; /* ignore, this is a comment line */ 554 if (parse_line(el, dptr) == -1) { 555 (void) fclose(fp); 556 return (-1); 557 } 558 } 559 560 (void) fclose(fp); 561 return (0); 562 } 563 564 565 /* el_resize(): 566 * Called from program when terminal is resized 567 */ 568 public void 569 el_resize(EditLine *el) 570 { 571 int lins, cols; 572 sigset_t oset, nset; 573 574 (void) sigemptyset(&nset); 575 (void) sigaddset(&nset, SIGWINCH); 576 (void) sigprocmask(SIG_BLOCK, &nset, &oset); 577 578 /* get the correct window size */ 579 if (term_get_size(el, &lins, &cols)) 580 term_change_size(el, lins, cols); 581 582 (void) sigprocmask(SIG_SETMASK, &oset, NULL); 583 } 584 585 586 /* el_beep(): 587 * Called from the program to beep 588 */ 589 public void 590 el_beep(EditLine *el) 591 { 592 593 term_beep(el); 594 } 595 596 597 /* el_editmode() 598 * Set the state of EDIT_DISABLED from the `edit' command. 599 */ 600 protected int 601 /*ARGSUSED*/ 602 el_editmode(EditLine *el, int argc, const Char **argv) 603 { 604 const Char *how; 605 606 if (argv == NULL || argc != 2 || argv[1] == NULL) 607 return (-1); 608 609 how = argv[1]; 610 if (Strcmp(how, STR("on")) == 0) { 611 el->el_flags &= ~EDIT_DISABLED; 612 tty_rawmode(el); 613 } else if (Strcmp(how, STR("off")) == 0) { 614 tty_cookedmode(el); 615 el->el_flags |= EDIT_DISABLED; 616 } 617 else { 618 (void) fprintf(el->el_errfile, "edit: Bad value `" FSTR "'.\n", 619 how); 620 return (-1); 621 } 622 return (0); 623 } 624