1 /* $NetBSD: el.c,v 1.28 2002/02/03 23:37:19 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. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 #if !defined(lint) && !defined(SCCSID) 41 #if 0 42 static char sccsid[] = "@(#)el.c 8.2 (Berkeley) 1/3/94"; 43 #else 44 __RCSID("$NetBSD: el.c,v 1.28 2002/02/03 23:37:19 christos Exp $"); 45 #endif 46 #endif /* not lint && not SCCSID */ 47 48 /* 49 * el.c: EditLine interface functions 50 */ 51 #include "sys.h" 52 53 #include <sys/types.h> 54 #include <sys/param.h> 55 #include <string.h> 56 #include <stdlib.h> 57 #include <stdarg.h> 58 #include "el.h" 59 60 /* el_init(): 61 * Initialize editline and set default parameters. 62 */ 63 public EditLine * 64 el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr) 65 { 66 67 EditLine *el = (EditLine *) el_malloc(sizeof(EditLine)); 68 69 if (el == NULL) 70 return (NULL); 71 72 memset(el, 0, sizeof(EditLine)); 73 74 el->el_infd = fileno(fin); 75 el->el_outfile = fout; 76 el->el_errfile = ferr; 77 el->el_prog = strdup(prog); 78 79 /* 80 * Initialize all the modules. Order is important!!! 81 */ 82 el->el_flags = 0; 83 84 if (term_init(el) == -1) { 85 free(el->el_prog); 86 el_free(el); 87 return NULL; 88 } 89 (void) key_init(el); 90 (void) map_init(el); 91 if (tty_init(el) == -1) 92 el->el_flags |= NO_TTY; 93 (void) ch_init(el); 94 (void) search_init(el); 95 (void) hist_init(el); 96 (void) prompt_init(el); 97 (void) sig_init(el); 98 (void) read_init(el); 99 100 return (el); 101 } 102 103 104 /* el_end(): 105 * Clean up. 106 */ 107 public void 108 el_end(EditLine *el) 109 { 110 111 if (el == NULL) 112 return; 113 114 el_reset(el); 115 116 term_end(el); 117 key_end(el); 118 map_end(el); 119 tty_end(el); 120 ch_end(el); 121 search_end(el); 122 hist_end(el); 123 prompt_end(el); 124 sig_end(el); 125 126 el_free((ptr_t) el->el_prog); 127 el_free((ptr_t) el); 128 } 129 130 131 /* el_reset(): 132 * Reset the tty and the parser 133 */ 134 public void 135 el_reset(EditLine *el) 136 { 137 138 tty_cookedmode(el); 139 ch_reset(el); /* XXX: Do we want that? */ 140 } 141 142 143 /* el_set(): 144 * set the editline parameters 145 */ 146 public int 147 el_set(EditLine *el, int op, ...) 148 { 149 va_list va; 150 int rv = 0; 151 152 if (el == NULL) 153 return (-1); 154 va_start(va, op); 155 156 switch (op) { 157 case EL_PROMPT: 158 case EL_RPROMPT: 159 rv = prompt_set(el, va_arg(va, el_pfunc_t), op); 160 break; 161 162 case EL_TERMINAL: 163 rv = term_set(el, va_arg(va, char *)); 164 break; 165 166 case EL_EDITOR: 167 rv = map_set_editor(el, va_arg(va, char *)); 168 break; 169 170 case EL_SIGNAL: 171 if (va_arg(va, int)) 172 el->el_flags |= HANDLE_SIGNALS; 173 else 174 el->el_flags &= ~HANDLE_SIGNALS; 175 break; 176 177 case EL_BIND: 178 case EL_TELLTC: 179 case EL_SETTC: 180 case EL_ECHOTC: 181 case EL_SETTY: 182 { 183 char *argv[20]; 184 int i; 185 186 for (i = 1; i < 20; i++) 187 if ((argv[i] = va_arg(va, char *)) == NULL) 188 break; 189 190 switch (op) { 191 case EL_BIND: 192 argv[0] = "bind"; 193 rv = map_bind(el, i, argv); 194 break; 195 196 case EL_TELLTC: 197 argv[0] = "telltc"; 198 rv = term_telltc(el, i, argv); 199 break; 200 201 case EL_SETTC: 202 argv[0] = "settc"; 203 rv = term_settc(el, i, argv); 204 break; 205 206 case EL_ECHOTC: 207 argv[0] = "echotc"; 208 rv = term_echotc(el, i, argv); 209 break; 210 211 case EL_SETTY: 212 argv[0] = "setty"; 213 rv = tty_stty(el, i, argv); 214 break; 215 216 default: 217 rv = -1; 218 EL_ABORT((el->el_errfile, "Bad op %d\n", op)); 219 break; 220 } 221 break; 222 } 223 224 case EL_ADDFN: 225 { 226 char *name = va_arg(va, char *); 227 char *help = va_arg(va, char *); 228 el_func_t func = va_arg(va, el_func_t); 229 230 rv = map_addfunc(el, name, help, func); 231 break; 232 } 233 234 case EL_HIST: 235 { 236 hist_fun_t func = va_arg(va, hist_fun_t); 237 ptr_t ptr = va_arg(va, char *); 238 239 rv = hist_set(el, func, ptr); 240 break; 241 } 242 243 case EL_EDITMODE: 244 if (va_arg(va, int)) 245 el->el_flags &= ~EDIT_DISABLED; 246 else 247 el->el_flags |= EDIT_DISABLED; 248 rv = 0; 249 break; 250 251 case EL_GETCFN: 252 { 253 el_rfunc_t rc = va_arg(va, el_rfunc_t); 254 rv = el_read_setfn(el, rc); 255 break; 256 } 257 258 case EL_CLIENTDATA: 259 el->el_data = va_arg(va, void *); 260 break; 261 262 default: 263 rv = -1; 264 break; 265 } 266 267 va_end(va); 268 return (rv); 269 } 270 271 272 /* el_get(): 273 * retrieve the editline parameters 274 */ 275 public int 276 el_get(EditLine *el, int op, void *ret) 277 { 278 int rv; 279 280 if (el == NULL || ret == NULL) 281 return (-1); 282 switch (op) { 283 case EL_PROMPT: 284 case EL_RPROMPT: 285 rv = prompt_get(el, (el_pfunc_t *) & ret, op); 286 break; 287 288 case EL_EDITOR: 289 rv = map_get_editor(el, (const char **) &ret); 290 break; 291 292 case EL_SIGNAL: 293 *((int *) ret) = (el->el_flags & HANDLE_SIGNALS); 294 rv = 0; 295 break; 296 297 case EL_EDITMODE: 298 *((int *) ret) = (!(el->el_flags & EDIT_DISABLED)); 299 rv = 0; 300 break; 301 302 #if 0 /* XXX */ 303 case EL_TERMINAL: 304 rv = term_get(el, (const char *) &ret); 305 break; 306 307 case EL_BIND: 308 case EL_TELLTC: 309 case EL_SETTC: 310 case EL_ECHOTC: 311 case EL_SETTY: 312 { 313 char *argv[20]; 314 int i; 315 316 for (i = 1; i < 20; i++) 317 if ((argv[i] = va_arg(va, char *)) == NULL) 318 break; 319 320 switch (op) { 321 case EL_BIND: 322 argv[0] = "bind"; 323 rv = map_bind(el, i, argv); 324 break; 325 326 case EL_TELLTC: 327 argv[0] = "telltc"; 328 rv = term_telltc(el, i, argv); 329 break; 330 331 case EL_SETTC: 332 argv[0] = "settc"; 333 rv = term_settc(el, i, argv); 334 break; 335 336 case EL_ECHOTC: 337 argv[0] = "echotc"; 338 rv = term_echotc(el, i, argv); 339 break; 340 341 case EL_SETTY: 342 argv[0] = "setty"; 343 rv = tty_stty(el, i, argv); 344 break; 345 346 default: 347 rv = -1; 348 EL_ABORT((el->errfile, "Bad op %d\n", op)); 349 break; 350 } 351 break; 352 } 353 354 case EL_ADDFN: 355 { 356 char *name = va_arg(va, char *); 357 char *help = va_arg(va, char *); 358 el_func_t func = va_arg(va, el_func_t); 359 360 rv = map_addfunc(el, name, help, func); 361 break; 362 } 363 364 case EL_HIST: 365 { 366 hist_fun_t func = va_arg(va, hist_fun_t); 367 ptr_t ptr = va_arg(va, char *); 368 rv = hist_set(el, func, ptr); 369 } 370 break; 371 #endif /* XXX */ 372 373 case EL_GETCFN: 374 *((el_rfunc_t *)ret) = el_read_getfn(el); 375 rv = 0; 376 break; 377 378 case EL_CLIENTDATA: 379 *((void **)ret) = el->el_data; 380 rv = 0; 381 break; 382 383 default: 384 rv = -1; 385 } 386 387 return (rv); 388 } 389 390 391 /* el_line(): 392 * Return editing info 393 */ 394 public const LineInfo * 395 el_line(EditLine *el) 396 { 397 398 return (const LineInfo *) (void *) &el->el_line; 399 } 400 401 402 /* el_source(): 403 * Source a file 404 */ 405 public int 406 el_source(EditLine *el, const char *fname) 407 { 408 FILE *fp; 409 size_t len; 410 char *ptr; 411 412 fp = NULL; 413 if (fname == NULL) { 414 #if 1 /* HAVE_ISSETUGID */ 415 static const char elpath[] = "/.editrc"; 416 char path[MAXPATHLEN]; 417 418 if (issetugid()) 419 return (-1); 420 if ((ptr = getenv("HOME")) == NULL) 421 return (-1); 422 if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path)) 423 return (-1); 424 if (strlcat(path, elpath, sizeof(path)) >= sizeof(path)) 425 return (-1); 426 fname = path; 427 #else 428 /* 429 * If issetugid() is missing, always return an error, in order 430 * to keep from inadvertently opening up the user to a security 431 * hole. 432 */ 433 return (-1); 434 #endif 435 } 436 if (fp == NULL) 437 fp = fopen(fname, "r"); 438 if (fp == NULL) 439 return (-1); 440 441 while ((ptr = fgetln(fp, &len)) != NULL) { 442 if (len > 0 && ptr[len - 1] == '\n') 443 --len; 444 ptr[len] = '\0'; 445 if (parse_line(el, ptr) == -1) { 446 (void) fclose(fp); 447 return (-1); 448 } 449 } 450 451 (void) fclose(fp); 452 return (0); 453 } 454 455 456 /* el_resize(): 457 * Called from program when terminal is resized 458 */ 459 public void 460 el_resize(EditLine *el) 461 { 462 int lins, cols; 463 sigset_t oset, nset; 464 465 (void) sigemptyset(&nset); 466 (void) sigaddset(&nset, SIGWINCH); 467 (void) sigprocmask(SIG_BLOCK, &nset, &oset); 468 469 /* get the correct window size */ 470 if (term_get_size(el, &lins, &cols)) 471 term_change_size(el, lins, cols); 472 473 (void) sigprocmask(SIG_SETMASK, &oset, NULL); 474 } 475 476 477 /* el_beep(): 478 * Called from the program to beep 479 */ 480 public void 481 el_beep(EditLine *el) 482 { 483 484 term_beep(el); 485 } 486 487 488 /* el_editmode() 489 * Set the state of EDIT_DISABLED from the `edit' command. 490 */ 491 protected int 492 /*ARGSUSED*/ 493 el_editmode(EditLine *el, int argc, char **argv) 494 { 495 const char *how; 496 497 if (argv == NULL || argc != 2 || argv[1] == NULL) 498 return (-1); 499 500 how = argv[1]; 501 if (strcmp(how, "on") == 0) 502 el->el_flags &= ~EDIT_DISABLED; 503 else if (strcmp(how, "off") == 0) 504 el->el_flags |= EDIT_DISABLED; 505 else { 506 (void) fprintf(el->el_errfile, "edit: Bad value `%s'.\n", how); 507 return (-1); 508 } 509 return (0); 510 } 511