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