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