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