/*      $NetBSD: complete.c,v 1.48 2024/09/25 16:53:58 christos Exp $   */

/*-
* Copyright (c) 1997-2009 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.
*/

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: complete.c,v 1.48 2024/09/25 16:53:58 christos Exp $");
#endif /* not lint */

/*
* FTP user program - command and file completion routines
*/

#include <sys/stat.h>

#include <ctype.h>
#include <err.h>
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "ftp_var.h"

#ifndef NO_EDITCOMPLETE

static int           comparstr          (const void *, const void *);
static unsigned char complete_ambiguous (char *, int, StringList *);
static unsigned char complete_command   (char *, int);
static unsigned char complete_local     (char *, int);
static unsigned char complete_option    (char *, int);
static unsigned char complete_remote    (char *, int);

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
*      list    list by default
*      words   stringlist containing possible matches
* Returns a result as per el_set(EL_ADDFN, ...)
*/
static unsigned char
complete_ambiguous(char *word, int list, StringList *words)
{
       char insertstr[MAXPATHLEN];
       char *lastmatch, *p;
       size_t i, j;
       size_t 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 (!list) {
               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);
               }
       }

       putc('\n', ttyout);
       qsort(words->sl_str, words->sl_cur, sizeof(char *), comparstr);
       list_vertical(words);
       return (CC_REDISPLAY);
}

/*
* Complete a command
*/
static unsigned char
complete_command(char *word, int list)
{
       struct cmd *c;
       StringList *words;
       size_t wordlen;
       unsigned char rv;

       words = ftp_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)
                       ftp_sl_add(words, ftp_strdup(c->c_name));
       }

       rv = complete_ambiguous(word, list, words);
       if (rv == CC_REFRESH) {
               if (el_insertstr(el, " ") == -1)
                       rv = CC_ERROR;
       }
       sl_free(words, 1);
       return (rv);
}

/*
* Complete a local file
*/
static unsigned char
complete_local(char *word, int list)
{
       StringList *words;
       char dir[MAXPATHLEN];
       char *file;
       DIR *dd;
       struct dirent *dp;
       unsigned char rv;
       size_t len;

       if ((file = strrchr(word, '/')) == NULL) {
               dir[0] = '.';
               dir[1] = '\0';
               file = word;
       } else {
               if (file == word) {
                       dir[0] = '/';
                       dir[1] = '\0';
               } else
                       (void)strlcpy(dir, word, file - word + 1);
               file++;
       }
       if (dir[0] == '~') {
               char *p;

               if ((p = globulize(dir)) == NULL)
                       return (CC_ERROR);
               (void)strlcpy(dir, p, sizeof(dir));
               free(p);
       }

       if ((dd = opendir(dir)) == NULL)
               return (CC_ERROR);

       words = ftp_sl_init();
       len = strlen(file);

       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(file, dp->d_name, len) == 0) {
                       char *tcp;

                       tcp = ftp_strdup(dp->d_name);
                       ftp_sl_add(words, tcp);
               }
       }
       closedir(dd);

       rv = complete_ambiguous(file, list, words);
       if (rv == CC_REFRESH) {
               struct stat sb;
               char path[MAXPATHLEN];

               (void)strlcpy(path, dir,                sizeof(path));
               (void)strlcat(path, "/",                sizeof(path));
               (void)strlcat(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);
}
/*
* Complete an option
*/
static unsigned char
complete_option(char *word, int list)
{
       struct option *o;
       StringList *words;
       size_t wordlen;
       unsigned char rv;

       words = ftp_sl_init();
       wordlen = strlen(word);

       for (o = optiontab; o->name != NULL; o++) {
               if (wordlen > strlen(o->name))
                       continue;
               if (strncmp(word, o->name, wordlen) == 0)
                       ftp_sl_add(words, ftp_strdup(o->name));
       }

       rv = complete_ambiguous(word, list, words);
       if (rv == CC_REFRESH) {
               if (el_insertstr(el, " ") == -1)
                       rv = CC_ERROR;
       }
       sl_free(words, 1);
       return (rv);
}

/*
* Complete a remote file
*/
static unsigned char
complete_remote(char *word, int list)
{
       static StringList *dirlist;
       static char      lastdir[MAXPATHLEN];
       StringList      *words;
       char             dir[MAXPATHLEN];
       char            *file, *cp;
       size_t           i;
       unsigned char    rv;
       char             cmdbuf[MAX_C_NAME];
       char            *dummyargv[3] = { NULL, NULL, NULL };

       (void)strlcpy(cmdbuf, "complete", sizeof(cmdbuf));
       dummyargv[0] = cmdbuf;
       dummyargv[1] = dir;

       if ((file = strrchr(word, '/')) == NULL) {
               dir[0] = '\0';
               file = word;
       } else {
               cp = file;
               while (*cp == '/' && cp > word)
                       cp--;
               (void)strlcpy(dir, word, cp - word + 2);
               file++;
       }

       if (dirchange || dirlist == NULL ||
           strcmp(dir, lastdir) != 0) {                /* dir not cached */
               const char *emesg;

               if (dirlist != NULL)
                       sl_free(dirlist, 1);
               dirlist = ftp_sl_init();

               mflag = 1;
               emesg = NULL;
               while ((cp = remglob(dummyargv, 0, &emesg)) != NULL) {
                       char *tcp;

                       if (!mflag)
                               continue;
                       if (*cp == '\0') {
                               mflag = 0;
                               continue;
                       }
                       tcp = strrchr(cp, '/');
                       if (tcp)
                               tcp++;
                       else
                               tcp = cp;
                       tcp = ftp_strdup(tcp);
                       ftp_sl_add(dirlist, tcp);
               }
               if (emesg != NULL) {
                       fprintf(ttyout, "\n%s\n", emesg);
                       return (CC_REDISPLAY);
               }
               (void)strlcpy(lastdir, dir, sizeof(lastdir));
               dirchange = 0;
       }

       words = ftp_sl_init();
       for (i = 0; i < dirlist->sl_cur; i++) {
               cp = dirlist->sl_str[i];
               if (strlen(file) > strlen(cp))
                       continue;
               if (strncmp(file, cp, strlen(file)) == 0)
                       ftp_sl_add(words, cp);
       }
       rv = complete_ambiguous(file, list, words);
       sl_free(words, 0);
       return (rv);
}

/*
* Generic complete routine
*/
unsigned char
complete(EditLine *cel, int ch __unused)
{
       static char word[FTPBUFLEN];
       static size_t lastc_argc, lastc_argo;

       struct cmd *c;
       const LineInfo *lf;
       int dolist, cmpltype;
       size_t celems, len;

       lf = el_line(cel);
       len = lf->lastchar - lf->buffer;
       if (len >= sizeof(line))
               return (CC_ERROR);
       (void)strlcpy(line, lf->buffer, len + 1);
       cursor_pos = line + (lf->cursor - lf->buffer);
       lastc_argc = cursor_argc;       /* remember last cursor pos */
       lastc_argo = cursor_argo;
       makeargv();                     /* build argc/argv of current line */

       if (cursor_argo >= sizeof(word))
               return (CC_ERROR);

       dolist = 0;
                       /* if cursor and word is same, list alternatives */
       if (lastc_argc == cursor_argc && lastc_argo == cursor_argo
           && strncmp(word, margv[cursor_argc] ? margv[cursor_argc] : "",
                       cursor_argo) == 0)
               dolist = 1;
       else if (cursor_argc < (size_t)margc)
               (void)strlcpy(word, margv[cursor_argc], cursor_argo + 1);
       word[cursor_argo] = '\0';

       if (cursor_argc == 0)
               return (complete_command(word, dolist));

       c = getcmd(margv[0]);
       if (c == (struct cmd *)-1 || c == 0)
               return (CC_ERROR);
       celems = strlen(c->c_complete);

               /* check for 'continuation' completes (which are uppercase) */
       if ((cursor_argc > celems) && (celems > 0)
           && isupper((unsigned char) c->c_complete[celems-1]))
               cursor_argc = celems;

       if (cursor_argc > celems)
               return (CC_ERROR);

       cmpltype = c->c_complete[cursor_argc - 1];
       switch (cmpltype) {
               case 'c':                       /* command complete */
               case 'C':
                       return (complete_command(word, dolist));
               case 'l':                       /* local complete */
               case 'L':
                       return (complete_local(word, dolist));
               case 'n':                       /* no complete */
               case 'N':                       /* no complete */
                       return (CC_ERROR);
               case 'o':                       /* local complete */
               case 'O':
                       return (complete_option(word, dolist));
               case 'r':                       /* remote complete */
               case 'R':
                       if (connected != -1) {
                               fputs("\nMust be logged in to complete.\n",
                                   ttyout);
                               return (CC_REDISPLAY);
                       }
                       return (complete_remote(word, dolist));
               default:
                       errx(1, "complete: unknown complete type `%c'",
                           cmpltype);
                       return (CC_ERROR);
       }
       /* NOTREACHED */
}

#endif /* !NO_EDITCOMPLETE */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.