/* $NetBSD: complete.c,v 1.25 2022/08/06 18:26:43 andvar Exp $ */ /*- * Copyright (c) 1997-2000,2005,2006 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Luke Mewburn. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * Most of this is derived or copied from src/usr.bin/ftp/complete.c (1.41). */ #ifdef USE_EDITLINE #include #ifndef lint __RCSID("$NetBSD: complete.c,v 1.25 2022/08/06 18:26:43 andvar Exp $"); #endif /* not lint */ /* * FTP user program - command and file completion routines */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "rcv.h" /* includes "glob.h" */ #include "extern.h" #include "complete.h" #ifdef MIME_SUPPORT #include "mime.h" #endif #include "sig.h" #ifdef THREAD_SUPPORT #include "thread.h" #endif #define BELL 0x7 /* * Global variables */ static int doglob = 1; /* glob local file names */ #define ttyout stdout #define ttywidth screenwidth /* in "glob.h" */ #define ttyheight screenheight /* in "glob.h" */ /************************************************************************/ /* from src/usr.bin/ftp/utils.h (1.135) - begin */ /* * List words in stringlist, vertically arranged */ static void list_vertical(StringList *sl) { int k; size_t i, j, columns, lines; char *p; size_t w, width; width = 0; for (i = 0; i < sl->sl_cur; i++) { w = strlen(sl->sl_str[i]); if (w > width) width = w; } width = (width + 8) &~ 7; columns = ttywidth / width; if (columns == 0) columns = 1; lines = (sl->sl_cur + columns - 1) / columns; k = 0; for (i = 0; i < lines; i++) { for (j = 0; j < columns; j++) { p = sl->sl_str[j * lines + i]; if (p) (void)fputs(p, ttyout); if (j * lines + i + lines >= sl->sl_cur) { (void)putc('\n', ttyout); break; } if (p) { w = strlen(p); while (w < width) { w = (w + 8) &~ 7; (void)putc('\t', ttyout); } } } if (ttyheight > 2 && ++k == ttyheight - 2) { int ch; k = 0; (void)fputs("--more--", ttyout); while ((ch = getchar()) != EOF && ch != ' ' && ch != 'q') (void)putc(BELL, ttyout); (void)fputs("\r \r", ttyout); if (ch == 'q') break; } } } /* * Copy characters from src into dst, \ quoting characters that require it */ static void ftpvis(char *dst, size_t dstlen, const char *src, size_t srclen) { size_t di, si; for (di = si = 0; src[si] != '\0' && di < dstlen && si < srclen; di++, si++) { switch (src[si]) { case '\\': case ' ': case '\t': case '\r': case '\n': case '"': dst[di++] = '\\'; if (di >= dstlen) break; /* FALLTHROUGH */ default: dst[di] = src[si]; } } dst[di] = '\0'; } /* * sl_init() with inbuilt error checking */ static StringList * mail_sl_init(void) { StringList *p; p = sl_init(); if (p == NULL) err(EXIT_FAILURE, "Unable to allocate memory for stringlist"); return p; } /* * sl_add() with inbuilt error checking */ static void mail_sl_add(StringList *sl, char *i) { if (sl_add(sl, i) == -1) err(EXIT_FAILURE, "Unable to add `%s' to stringlist", i); } /* * Glob a local file name specification with the expectation of a single * return value. Can't control multiple values being expanded from the * expression, we return only the first. * Returns NULL on error, or a pointer to a buffer containing the filename * that's the caller's responsibility to free(3) when finished with. */ static char * globulize(const char *pattern) { glob_t gl; int flags; char *p; if (!doglob) return estrdup(pattern); flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_TILDE; (void)memset(&gl, 0, sizeof(gl)); if (glob(pattern, flags, NULL, &gl) || gl.gl_pathc == 0) { warnx("%s: not found", pattern); globfree(&gl); return NULL; } p = estrdup(gl.gl_pathv[0]); globfree(&gl); return p; } /* from src/usr.bin/ftp/utils.h (1.135) - end */ /************************************************************************/ static int comparstr(const void *a, const void *b) { return strcmp(*(const char * const *)a, *(const char * const *)b); } /* * Determine if complete is ambiguous. If unique, insert. * If no choices, error. If unambiguous prefix, insert that. * Otherwise, list choices. words is assumed to be filtered * to only contain possible choices. * Args: * word word which started the match * dolist list by default * words stringlist containing possible matches * Returns a result as per el_set(EL_ADDFN, ...) */ static unsigned char complete_ambiguous(EditLine *el, char *word, int dolist, StringList *words) { char insertstr[MAXPATHLEN]; char *lastmatch, *p; size_t i, j, matchlen, wordlen; wordlen = strlen(word); if (words->sl_cur == 0) return CC_ERROR; /* no choices available */ if (words->sl_cur == 1) { /* only once choice available */ p = words->sl_str[0] + wordlen; if (*p == '\0') /* at end of word? */ return CC_REFRESH; ftpvis(insertstr, sizeof(insertstr), p, strlen(p)); if (el_insertstr(el, insertstr) == -1) return CC_ERROR; else return CC_REFRESH; } if (!dolist) { matchlen = 0; lastmatch = words->sl_str[0]; matchlen = strlen(lastmatch); for (i = 1; i < words->sl_cur; i++) { for (j = wordlen; j < strlen(words->sl_str[i]); j++) if (lastmatch[j] != words->sl_str[i][j]) break; if (j < matchlen) matchlen = j; } if (matchlen >= wordlen) { ftpvis(insertstr, sizeof(insertstr), lastmatch + wordlen, matchlen - wordlen); if (el_insertstr(el, insertstr) == -1) return CC_ERROR; else return CC_REFRESH_BEEP; } } (void)putc('\n', ttyout); qsort(words->sl_str, words->sl_cur, sizeof(char *), comparstr); list_vertical(words); return CC_REDISPLAY; } /* * Complete a mail command. */ static unsigned char complete_command(EditLine *el, char *word, int dolist) { const struct cmd *c; StringList *words; size_t wordlen; unsigned char rv; words = mail_sl_init(); wordlen = strlen(word); for (c = cmdtab; c->c_name != NULL; c++) { if (wordlen > strlen(c->c_name)) continue; if (strncmp(word, c->c_name, wordlen) == 0) mail_sl_add(words, __UNCONST(c->c_name)); } rv = complete_ambiguous(el, word, dolist, words); if (rv == CC_REFRESH) { if (el_insertstr(el, " ") == -1) rv = CC_ERROR; } sl_free(words, 0); return rv; } /* * Complete a local filename. */ static unsigned char complete_filename(EditLine *el, char *word, int dolist) { StringList *words; char dir[MAXPATHLEN]; char *fname, *mf; DIR *dd; struct dirent *dp; unsigned char rv; size_t len; if ((fname = strrchr(word, '/')) == NULL) { if (word[0] == '+' && (mf = value(ENAME_FOLDER)) != NULL) { if (mf[0] == '/') { (void)estrlcpy(dir, mf, sizeof(dir)); } else { dir[0] = '~'; dir[1] = '/'; (void)estrlcpy(dir + 2, mf, sizeof(dir) - 2); } fname = word + 1; } else { dir[0] = '.'; dir[1] = '\0'; fname = word; } } else { if (fname == word) { dir[0] = '/'; dir[1] = '\0'; } else { len = fname - word + 1; (void)estrlcpy(dir, word, sizeof(dir)); dir[len] = '\0'; } fname++; } if (dir[0] == '~') { char *p; if ((p = globulize(dir)) == NULL) return CC_ERROR; (void)estrlcpy(dir, p, sizeof(dir)); free(p); } if ((dd = opendir(dir)) == NULL) return CC_ERROR; words = mail_sl_init(); len = strlen(fname); for (dp = readdir(dd); dp != NULL; dp = readdir(dd)) { if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue; #if defined(DIRENT_MISSING_D_NAMLEN) if (len > strlen(dp->d_name)) continue; #else if (len > dp->d_namlen) continue; #endif if (strncmp(fname, dp->d_name, len) == 0) { char *tcp; tcp = estrdup(dp->d_name); mail_sl_add(words, tcp); } } (void)closedir(dd); rv = complete_ambiguous(el, fname, dolist, words); if (rv == CC_REFRESH) { struct stat sb; char path[MAXPATHLEN]; (void)estrlcpy(path, dir, sizeof(path)); (void)estrlcat(path, "/", sizeof(path)); (void)estrlcat(path, words->sl_str[0], sizeof(path)); if (stat(path, &sb) >= 0) { char suffix[2] = " "; if (S_ISDIR(sb.st_mode)) suffix[0] = '/'; if (el_insertstr(el, suffix) == -1) rv = CC_ERROR; } } sl_free(words, 1); return rv; } static int find_execs(char *word, char *path, StringList *list) { char *sep; char *dir=path; DIR *dd; struct dirent *dp; size_t len = strlen(word); uid_t uid = getuid(); gid_t gid = getgid(); for (sep = dir; sep; dir = sep + 1) { if ((sep=strchr(dir, ':')) != NULL) { *sep=0; } if ((dd = opendir(dir)) == NULL) { perror("dir"); return -1; } for (dp = readdir(dd); dp != NULL; dp = readdir(dd)) { if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue; #if defined(DIRENT_MISSING_D_NAMLEN) if (len > strlen(dp->d_name)) continue; #else if (len > dp->d_namlen) continue; #endif if (strncmp(word, dp->d_name, len) == 0) { struct stat sb; char pathname[ MAXPATHLEN ]; unsigned mask; (void)snprintf(pathname, sizeof(pathname), "%s/%s", dir, dp->d_name); if (stat(pathname, &sb) != 0) { perror(pathname); continue; } mask = 0001; if (sb.st_uid == uid) mask |= 0100; if (sb.st_gid == gid) mask |= 0010; if ((sb.st_mode & mask) != 0) { char *tcp; tcp = estrdup(dp->d_name); mail_sl_add(list, tcp); } } } (void)closedir(dd); } return 0; } /* * Complete a local executable */ static unsigned char complete_executable(EditLine *el, char *word, int dolist) { StringList *words; char dir[ MAXPATHLEN ]; char *fname; unsigned char rv; size_t len; int error; if ((fname = strrchr(word, '/')) == NULL) { dir[0] = '\0'; /* walk the path */ fname = word; } else { if (fname == word) { dir[0] = '/'; dir[1] = '\0'; } else { len = fname - word; (void)strncpy(dir, word, len); dir[fname - word] = '\0'; } fname++; } words = sl_init(); if (*dir == '\0') { /* walk path */ char *env; char *path; env = getenv("PATH"); len = strlen(env); path = salloc(len + 1); (void)strcpy(path, env); error = find_execs(word, path, words); } else { /* check specified dir only */ error = find_execs(word, dir, words); } if (error != 0) return CC_ERROR; rv = complete_ambiguous(el, fname, dolist, words); if (rv == CC_REFRESH) { if (el_insertstr(el, " ") == -1) rv = CC_ERROR; } sl_free(words, 1); return rv; } static unsigned char complete_set(EditLine *el, char *word, int dolist) { struct var *vp; const char **ap; const char **p; int h; int s; size_t len = strlen(word); StringList *words; unsigned char rv; words = sl_init(); /* allocate space for variables table */ s = 1; for (h = 0; h < HSHSIZE; h++) for (vp = variables[h]; vp != NULL; vp = vp->v_link) s++; ap = salloc(s * sizeof(*ap)); /* save the pointers */ for (h = 0, p = ap; h < HSHSIZE; h++) for (vp = variables[h]; vp != NULL; vp = vp->v_link) *p++ = vp->v_name; *p = NULL; sort(ap); for (p = ap; *p != NULL; p++) if (len == 0 || strncmp(*p, word, len) == 0) mail_sl_add(words, estrdup(*p)); rv = complete_ambiguous(el, word, dolist, words); sl_free(words, 1); return rv; } static unsigned char complete_alias(EditLine *el, char *word, int dolist) { struct grouphead *gh; const char **ap; const char **p; int h; int s; size_t len = strlen(word); StringList *words; unsigned char rv; words = sl_init(); /* allocate space for alias table */ s = 1; for (h = 0; h < HSHSIZE; h++) for (gh = groups[h]; gh != NULL; gh = gh->g_link) s++; ap = salloc(s * sizeof(*ap)); /* save pointers */ p = ap; for (h = 0; h < HSHSIZE; h++) for (gh = groups[h]; gh != NULL; gh = gh->g_link) *p++ = gh->g_name; *p = NULL; sort(ap); for (p = ap; *p != NULL; p++) if (len == 0 || strncmp(*p, word, len) == 0) mail_sl_add(words, estrdup(*p)); rv = complete_ambiguous(el, word, dolist, words); if (rv == CC_REFRESH) { if (el_insertstr(el, " ") == -1) rv = CC_ERROR; } sl_free(words, 1); return rv; } static unsigned char complete_smopts(EditLine *el, char *word, int dolist) { struct grouphead *gh; struct smopts_s *sp; const char **ap; const char **p; int h; int s1; int s2; size_t len; StringList *words; unsigned char rv; len = strlen(word); words = sl_init(); /* count the entries in the smoptstbl and groups (alias) tables */ s1 = 1; s2 = 1; for (h = 0; h < HSHSIZE; h++) { for (sp = smoptstbl[h]; sp != NULL; sp = sp->s_link) s1++; for (gh = groups[h]; gh != NULL; gh = gh->g_link) s2++; } /* allocate sufficient space for the pointers */ ap = salloc(MAX(s1, s2) * sizeof(*ap)); /* * First do the smoptstbl pointers. (case _insensitive_) */ p = ap; for (h = 0; h < HSHSIZE; h++) for (sp = smoptstbl[h]; sp != NULL; sp = sp->s_link) *p++ = sp->s_name; *p = NULL; sort(ap); for (p = ap; *p != NULL; p++) if (len == 0 || strncasecmp(*p, word, len) == 0) mail_sl_add(words, estrdup(*p)); /* * Now do the groups (alias) pointers. (case sensitive) */ p = ap; for (h = 0; h < HSHSIZE; h++) for (gh = groups[h]; gh != NULL; gh = gh->g_link) *p++ = gh->g_name; *p = NULL; sort(ap); for (p = ap; *p != NULL; p++) if (len == 0 || strncmp(*p, word, len) == 0) mail_sl_add(words, estrdup(*p)); rv = complete_ambiguous(el, word, dolist, words); sl_free(words, 1); return rv; } #ifdef THREAD_SUPPORT static unsigned char complete_thread_key(EditLine *el, char *word, int dolist) { const char **ap; const char **p; const char *name; size_t len; StringList *words; unsigned char rv; int cnt; const void *cookie; len = strlen(word); words = sl_init(); /* count the entries in the table */ /* XXX - have a function return this rather than counting? */ cnt = 1; /* count the NULL terminator */ cookie = NULL; while (thread_next_key_name(&cookie) != NULL) cnt++; /* allocate sufficient space for the pointers */ ap = salloc(cnt * sizeof(*ap)); /* load the array */ p = ap; cookie = NULL; while ((name = thread_next_key_name(&cookie)) != NULL) *p++ = name; *p = NULL; sort(ap); for (p = ap; *p != NULL; p++) if (len == 0 || strncmp(*p, word, len) == 0) mail_sl_add(words, estrdup(*p)); rv = complete_ambiguous(el, word, dolist, words); sl_free(words, 1); return rv; } #endif /* THREAD_SUPPORT */ /* from /usr/src/usr.bin/ftp/main.c(1.101) - end */ /************************************************************************/ /* Some people like to bind file completion to CTRL-D. In emacs mode, * CTRL-D is also used to delete the current character, we have to * special case this situation. */ #define EMACS_CTRL_D_BINDING_HACK #ifdef EMACS_CTRL_D_BINDING_HACK static int is_emacs_mode(EditLine *el) { char *mode; if (el_get(el, EL_EDITOR, &mode) == -1) return 0; return equal(mode, "emacs"); } static int emacs_ctrl_d(EditLine *el, const LineInfo *lf, int ch) { static char delunder[3] = { CTRL('f'), CTRL('h'), '\0' }; if (ch == CTRL('d') && is_emacs_mode(el)) { /* CTRL-D is special */ if (lf->buffer == lf->lastchar) return CC_EOF; if (lf->cursor != lf->lastchar) { /* delete without using ^D */ el_push(el, delunder); /* ^F^H */ return CC_NORM; } } return -1; } #endif /* EMACS_CTRL_D_BINDING_HACK */ /* * Check if this is the second request made for this line indicating * the need to list all the completion possibilities. */ static int get_dolist(const LineInfo *lf) { static char last_line[LINESIZE]; static char *last_cursor_pos; char *cursor_pos; int dolist; size_t len; len = lf->lastchar - lf->buffer; if (len >= sizeof(last_line) - 1) return -1; cursor_pos = last_line + (lf->cursor - lf->buffer); dolist = cursor_pos == last_cursor_pos && strncmp(last_line, lf->buffer, len) == 0; (void)strlcpy(last_line, lf->buffer, len + 1); last_cursor_pos = cursor_pos; return dolist; } /* * Take the full line (lf) including the command and split it into a * sub-line (returned) and a completion context (cmplarray). */ static LineInfo * split_line(const char **cmplarray, const LineInfo *lf) { static LineInfo li; const struct cmd *c; char *cmdname; char line[LINESIZE]; char *cp; size_t len; len = lf->cursor - lf->buffer; if (len + 1 > sizeof(line)) return NULL; (void)strlcpy(line, lf->buffer, len + 1); li.cursor = line + len; li.lastchar = line + len; cp = skip_WSP(line); cmdname = get_cmdname(cp); cp += strlen(cmdname); if (cp == li.cursor) { *cmplarray = "c"; li.buffer = cmdname; return &li; } c = lex(cmdname); if (c == NULL) return NULL; *cmplarray = c->c_complete; if (c->c_pipe) { char *cp2; if ((cp2 = shellpr(cp)) != NULL) { cp = cp2; # define XX(a) ((a) + ((a)[1] == '>' ? 2 : 1)) while ((cp2 = shellpr(XX(cp))) != NULL) cp = cp2; if (*cp == '|') { *cmplarray = "xF"; cp = skip_WSP(cp + 1); } else { assert(*cp == '>'); cp = skip_WSP(XX(cp)); *cmplarray = "f"; } # undef XX } } li.buffer = cp; return &li; } /* * Split a sub-line and a completion context into a word and a * completion type. Use the editline tokenizer to handle the quoting * and splitting. */ static char * split_word(int *cmpltype, const char *cmplarray, LineInfo *li) { static Tokenizer *t = NULL; const char **argv; char *word; int argc; int cursorc; int cursoro; int arraylen; if (t != NULL) tok_reset(t); else { if ((t = tok_init(NULL)) == NULL) err(EXIT_FAILURE, "tok_init"); } if (tok_line(t, li, &argc, &argv, &cursorc, &cursoro) == -1) err(EXIT_FAILURE, "tok_line"); if (cursorc >= argc) word = __UNCONST(""); else { word = salloc((size_t)cursoro + 1); (void)strlcpy(word, argv[cursorc], (size_t)cursoro + 1); } /* check for 'continuation' completes (which are uppercase) */ arraylen = (int)strlen(cmplarray); if (cursorc >= arraylen && arraylen > 0 && isupper((unsigned char)cmplarray[arraylen - 1])) cursorc = arraylen - 1; if (cursorc >= arraylen) return NULL; *cmpltype = cmplarray[cursorc]; return word; } /* * A generic complete routine for the mail command line. */ static unsigned char mail_complete(EditLine *el, int ch) { LineInfo *li; const LineInfo *lf; const char *cmplarray; int dolist; int cmpltype; char *word; lf = el_line(el); #ifdef EMACS_CTRL_D_BINDING_HACK { int cc_ret; if ((cc_ret = emacs_ctrl_d(el, lf, ch)) != -1) return cc_ret; } #endif /* EMACS_CTRL_D_BINDING_HACK */ if ((dolist = get_dolist(lf)) == -1) return CC_ERROR; if ((li = split_line(&cmplarray, lf)) == NULL) return CC_ERROR; if ((word = split_word(&cmpltype, cmplarray, li)) == NULL) return CC_ERROR; switch (cmpltype) { case 'a': /* alias complete */ case 'A': return complete_alias(el, word, dolist); case 'c': /* command complete */ case 'C': return complete_command(el, word, dolist); case 'f': /* filename complete */ case 'F': return complete_filename(el, word, dolist); case 'm': case 'M': return complete_smopts(el, word, dolist); case 'n': /* no complete */ case 'N': /* no complete */ return CC_ERROR; case 's': case 'S': return complete_set(el, word, dolist); #ifdef THREAD_SUPPORT case 't': case 'T': return complete_thread_key(el, word, dolist); #endif case 'x': /* executable complete */ case 'X': return complete_executable(el, word, dolist); default: warnx("unknown complete type `%c'", cmpltype); #if 0 assert(/*CONSTCOND*/0); #endif return CC_ERROR; } /* NOTREACHED */ } /* * A generic file completion routine. */ static unsigned char file_complete(EditLine *el, int ch) { static char word[LINESIZE]; const LineInfo *lf; size_t word_len; int dolist; lf = el_line(el); #ifdef EMACS_CTRL_D_BINDING_HACK { int cc_ret; if ((cc_ret = emacs_ctrl_d(el, lf, ch)) != -1) return cc_ret; } #endif /* EMACS_CTRL_D_BINDING_HACK */ word_len = lf->cursor - lf->buffer; if (word_len + 1 > sizeof(word)) return CC_ERROR; (void)strlcpy(word, lf->buffer, word_len + 1); /* do not use estrlcpy here! */ if ((dolist = get_dolist(lf)) == -1) return CC_ERROR; return complete_filename(el, word, dolist); } #ifdef MIME_SUPPORT /* * Complete mime_transfer_encoding type. */ static unsigned char mime_enc_complete(EditLine *el, int ch) { static char word[LINESIZE]; StringList *words; unsigned char rv; const LineInfo *lf; size_t word_len; int dolist; lf = el_line(el); #ifdef EMACS_CTRL_D_BINDING_HACK { int cc_ret; if ((cc_ret = emacs_ctrl_d(el, lf, ch)) != -1) return cc_ret; } #endif /* EMACS_CTRL_D_BINDING_HACK */ word_len = lf->cursor - lf->buffer; if (word_len >= sizeof(word) - 1) return CC_ERROR; words = mail_sl_init(); { const char *ename; const void *cookie; cookie = NULL; for (ename = mime_next_encoding_name(&cookie); ename; ename = mime_next_encoding_name(&cookie)) if (word_len == 0 || strncmp(lf->buffer, ename, word_len) == 0) { char *cp; cp = estrdup(ename); mail_sl_add(words, cp); } } (void)strlcpy(word, lf->buffer, word_len + 1); if ((dolist = get_dolist(lf)) == -1) return CC_ERROR; rv = complete_ambiguous(el, word, dolist, words); sl_free(words, 1); return rv; } #endif /* MIME_SUPPORT */ /************************************************************************* * Our public interface to el_gets(): * * init_editline() * Initializes of all editline and completion data structures. * * my_gets() * Displays prompt, calls el_gets() and deals with history. * Returns the next line of input as a NULL termnated string * without the trailing newline, or NULL if el_gets() sees is an * error or signal. */ static const char *el_prompt; /*ARGSUSED*/ static const char * show_prompt(EditLine *e __unused) { return el_prompt; } /* * Write the current INTR character to fp in a friendly form. */ static void echo_INTR(void *p) { struct termios ttybuf; char buf[5]; FILE *fp; fp = p; if (tcgetattr(fileno(stdin), &ttybuf) == -1) warn("tcgetattr"); else { (void)vis(buf, ttybuf.c_cc[VINTR], VIS_SAFE | VIS_NOSLASH, 0); (void)fprintf(fp, "%s", buf); (void)fflush(fp); } } static sig_t old_sigint; static void comp_intr(int signo) { echo_INTR(stdout); old_sigint(signo); } PUBLIC char * my_gets(el_mode_t *em, const char *prompt, char *string) { static char line[LINE_MAX]; size_t len; int cnt; const char *buf; HistEvent ev; sig_check(); el_prompt = prompt; if (string) el_push(em->el, string); /* * Let el_gets() deal with flow control. Also, make sure we * output a ^C when we get a SIGINT as el_gets() doesn't echo * one. */ old_sigint = sig_signal(SIGINT, comp_intr); buf = el_gets(em->el, &cnt); (void)sig_signal(SIGINT, old_sigint); if (buf == NULL) { sig_check(); return NULL; } if (cnt > 0) { if (buf[cnt - 1] == '\n') cnt--; /* trash the trailing LF */ len = MIN(sizeof(line) - 1, (size_t)cnt); (void)memcpy(line, buf, len); } line[cnt] = '\0'; /* enter non-empty lines into history */ if (em->hist) { const char *p; p = skip_WSP(line); if (*p && history(em->hist, &ev, H_ENTER, line) == 0) (void)printf("Failed history entry: %s", line); } sig_check(); return line; } static el_mode_t init_el_mode( const char *el_editor, unsigned char (*completer)(EditLine *, int), struct name *keys, int history_size) { FILE *nullfp; el_mode_t em; (void)memset(&em, 0, sizeof(em)); if ((nullfp = fopen(_PATH_DEVNULL, "w")) == NULL) err(EXIT_FAILURE, "Cannot open `%s'", _PATH_DEVNULL); if ((em.el = el_init(getprogname(), stdin, stdout, nullfp)) == NULL) { warn("el_init"); return em; } (void)fflush(nullfp); (void)dup2(STDERR_FILENO, fileno(nullfp)); (void)el_set(em.el, EL_PROMPT, show_prompt); (void)el_set(em.el, EL_SIGNAL, 1); /* editline handles the signals. */ if (el_editor) (void)el_set(em.el, EL_EDITOR, el_editor); if (completer) { struct name *np; (void)el_set(em.el, EL_ADDFN, "mail-complete", "Context sensitive argument completion", completer); for (np = keys; np; np = np->n_flink) (void)el_set(em.el, EL_BIND, np->n_name, "mail-complete", NULL); } if (history_size) { HistEvent ev; if ((em.hist = history_init()) == NULL) { warn("history_init"); return em; } if (history(em.hist, &ev, H_SETSIZE, history_size) == -1) (void)printf("history: %s\n", ev.str); (void)el_set(em.el, EL_HIST, history, em.hist); } (void)el_source(em.el, NULL); /* read ~/.editrc */ return em; } struct el_modes_s elm = { .command = { .el = NULL, .hist = NULL, }, .string = { .el = NULL, .hist = NULL, }, .filec = { .el = NULL, .hist = NULL, }, #ifdef MIME_SUPPORT .mime_enc = { .el = NULL, .hist = NULL, }, #endif }; PUBLIC void init_editline(void) { const char *mode; int hist_size; struct name *keys; char *cp; mode = value(ENAME_EL_EDITOR); cp = value(ENAME_EL_HISTORY_SIZE); hist_size = cp ? atoi(cp) : 0; cp = value(ENAME_EL_COMPLETION_KEYS); keys = cp && *cp ? lexpand(cp, 0) : NULL; elm.command = init_el_mode(mode, mail_complete, keys, hist_size); elm.filec = init_el_mode(mode, file_complete, keys, 0); elm.string = init_el_mode(mode, NULL, NULL, 0); #ifdef MIME_SUPPORT elm.mime_enc = init_el_mode(mode, mime_enc_complete, keys, 0); #endif return; } #endif /* USE_EDITLINE */