Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/ftp/complete.c	Lines:	0	156	0.0 %
Date:	2016-12-06	Branches:	0	115	0.0 %


/*	$OpenBSD: complete.c,v 1.29 2015/10/18 03:04:11 mmcc Exp $	*/
/*	$NetBSD: complete.c,v 1.10 1997/08/18 10:20:18 lukem Exp $	*/

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

#ifndef SMALL

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

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

#include "ftp_var.h"

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_remote(char *, int);
static void          ftpvis(char *, size_t, const char *, size_t);

static int
comparstr(const void *a, const void *b)
{
	return (strcmp(*(char **)a, *(char **)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
 */
static unsigned char
complete_ambiguous(char *word, int list, StringList *words)
{
	char insertstr[PATH_MAX * 2];
	char *lastmatch;
	int 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 */
		char *p = words->sl_str[0] + wordlen;
		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
					/*
					 * XXX: really want CC_REFRESH_BEEP
					 */
				return (CC_REFRESH);
		}
	}

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

	rv = complete_ambiguous(word, list, words);
	sl_free(words, 0);
	return (rv);
}

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

	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, (size_t)(file - word) + 1);
		}
		file++;
	}

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

	words = sl_init();

	for (dp = readdir(dd); dp != NULL; dp = readdir(dd)) {
		if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
			continue;
		if (strlen(file) > dp->d_namlen)
			continue;
		if (strncmp(file, dp->d_name, strlen(file)) == 0) {
			char *tcp;

			tcp = strdup(dp->d_name);
			if (tcp == NULL)
				errx(1, "Can't allocate memory for local dir");
			sl_add(words, tcp);
		}
	}
	closedir(dd);

	rv = complete_ambiguous(file, list, words);
	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[PATH_MAX];
	StringList	*words;
	char		 dir[PATH_MAX];
	char		*file, *cp;
	int		 i;
	unsigned char	 rv;

	char *dummyargv[] = { "complete", dir, NULL };

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

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

		sl_free(dirlist, 1);
		dirlist = sl_init();

		mflag = 1;
		emesg = NULL;
		if (debug)
			(void)putc('\n', ttyout);
		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 = strdup(tcp);
			if (tcp == NULL)
				errx(1, "Can't allocate memory for remote dir");
			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 = 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)
			sl_add(words, cp);
	}
	rv = complete_ambiguous(file, list, words);
	sl_free(words, 0);
	return (rv);
}

/*
 * Generic complete routine
 */
unsigned char
complete(EditLine *el, int ch)
{
	static char word[FTPBUFLEN];
	static int lastc_argc, lastc_argo;
	struct cmd *c;
	const LineInfo *lf;
	int celems, dolist;
	size_t len;

	ch = ch;		/* not used */
	lf = el_line(el);
	len = lf->lastchar - lf->buffer;
	if (len >= sizeof(line))
		return (CC_ERROR);
	(void)memcpy(line, lf->buffer, len);
	line[len] = '\0';
	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], cursor_argo) == 0)
		dolist = 1;
	else if (cursor_argo)
		memcpy(word, margv[cursor_argc], cursor_argo);
	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);

	switch (c->c_complete[cursor_argc - 1]) {
	case 'l':			/* local complete */
	case 'L':
		return (complete_local(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));
	case 'c':			/* command complete */
	case 'C':
		return (complete_command(word, dolist));
	case 'n':			/* no complete */
		return (CC_ERROR);
	}

	return (CC_ERROR);
}

/*
 * 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;

	di = si = 0;
	while (di + 1 < dstlen && si < srclen && src[si] != '\0') {
		switch (src[si]) {
		case '\\':
		case ' ':
		case '\t':
		case '\r':
		case '\n':
		case '"':
			/* Need room for two characters and NUL, avoiding
			 * incomplete escape sequences at end of dst. */
			if (di + 3 >= dstlen)
				break;
			dst[di++] = '\\';
			/* FALLTHROUGH */
		default:
			dst[di++] = src[si++];
		}
	}
	if (dstlen != 0)
		dst[di] = '\0';
}
#endif /* !SMALL */


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: complete.c,v 1.29 2015/10/18 03:04:11 mmcc Exp $ */
2			/* $NetBSD: complete.c,v 1.10 1997/08/18 10:20:18 lukem Exp $ */
3
4			/*-
5			* Copyright (c) 1997 The NetBSD Foundation, Inc.
6			* All rights reserved.
7			*
8			* This code is derived from software contributed to The NetBSD Foundation
9			* by Luke Mewburn.
10			*
11			* Redistribution and use in source and binary forms, with or without
12			* modification, are permitted provided that the following conditions
13			* are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above copyright
17			* notice, this list of conditions and the following disclaimer in the
18			* documentation and/or other materials provided with the distribution.
19			*
20			* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21			* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22			* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23			* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24			* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25			* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26			* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27			* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28			* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29			* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30			* POSSIBILITY OF SUCH DAMAGE.
31			*/
32
33			#ifndef SMALL
34
35			/*
36			* FTP user program - command and file completion routines
37			*/
38
39			#include <ctype.h>
40			#include <err.h>
41			#include <dirent.h>
42			#include <stdio.h>
43			#include <stdlib.h>
44			#include <string.h>
45
46			#include "ftp_var.h"
47
48			static int comparstr(const void , const void );
49			static unsigned char complete_ambiguous(char , int, StringList );
50			static unsigned char complete_command(char *, int);
51			static unsigned char complete_local(char *, int);
52			static unsigned char complete_remote(char *, int);
53			static void ftpvis(char , size_t, const char , size_t);
54
55			static int
56			comparstr(const void a, const void b)
57			{
58			return (strcmp((char )a, (char **)b));
59			}
60
61			/*
62			* Determine if complete is ambiguous. If unique, insert.
63			* If no choices, error. If unambiguous prefix, insert that.
64			* Otherwise, list choices. words is assumed to be filtered
65			* to only contain possible choices.
66			* Args:
67			* word word which started the match
68			* list list by default
69			* words stringlist containing possible matches
70			*/
71			static unsigned char
72			complete_ambiguous(char word, int list, StringList words)
73			{
74			char insertstr[PATH_MAX * 2];
75			char *lastmatch;
76			int i, j;
77			size_t matchlen, wordlen;
78
79			wordlen = strlen(word);
80			if (words->sl_cur == 0)
81			return (CC_ERROR); /* no choices available */
82
83			if (words->sl_cur == 1) { /* only once choice available */
84			char *p = words->sl_str[0] + wordlen;
85			ftpvis(insertstr, sizeof(insertstr), p, strlen(p));
86			if (el_insertstr(el, insertstr) == -1)
87			return (CC_ERROR);
88			else
89			return (CC_REFRESH);
90			}
91
92			if (!list) {
93			lastmatch = words->sl_str[0];
94			matchlen = strlen(lastmatch);
95			for (i = 1 ; i < words->sl_cur ; i++) {
96			for (j = wordlen ; j < strlen(words->sl_str[i]); j++)
97			if (lastmatch[j] != words->sl_str[i][j])
98			break;
99			if (j < matchlen)
100			matchlen = j;
101			}
102			if (matchlen > wordlen) {
103			ftpvis(insertstr, sizeof(insertstr),
104			lastmatch + wordlen, matchlen - wordlen);
105			if (el_insertstr(el, insertstr) == -1)
106			return (CC_ERROR);
107			else
108			/*
109			* XXX: really want CC_REFRESH_BEEP
110			*/
111			return (CC_REFRESH);
112			}
113			}
114
115			putc('\n', ttyout);
116			qsort(words->sl_str, words->sl_cur, sizeof(char *), comparstr);
117			list_vertical(words);
118			return (CC_REDISPLAY);
119			}
120
121			/*
122			* Complete a command
123			*/
124			static unsigned char
125			complete_command(char *word, int list)
126			{
127			struct cmd *c;
128			StringList *words;
129			size_t wordlen;
130			unsigned char rv;
131
132			words = sl_init();
133			wordlen = strlen(word);
134
135			for (c = cmdtab; c->c_name != NULL; c++) {
136			if (wordlen > strlen(c->c_name))
137			continue;
138			if (strncmp(word, c->c_name, wordlen) == 0)
139			sl_add(words, c->c_name);
140			}
141
142			rv = complete_ambiguous(word, list, words);
143			sl_free(words, 0);
144			return (rv);
145			}
146
147			/*
148			* Complete a local file
149			*/
150			static unsigned char
151			complete_local(char *word, int list)
152			{
153			StringList *words;
154			char dir[PATH_MAX];
155			char *file;
156			DIR *dd;
157			struct dirent *dp;
158			unsigned char rv;
159
160			if ((file = strrchr(word, '/')) == NULL) {
161			dir[0] = '.';
162			dir[1] = '\0';
163			file = word;
164			} else {
165			if (file == word) {
166			dir[0] = '/';
167			dir[1] = '\0';
168			} else {
169			(void)strlcpy(dir, word, (size_t)(file - word) + 1);
170			}
171			file++;
172			}
173
174			if ((dd = opendir(dir)) == NULL)
175			return (CC_ERROR);
176
177			words = sl_init();
178
179			for (dp = readdir(dd); dp != NULL; dp = readdir(dd)) {
180			if (!strcmp(dp->d_name, ".") \|\| !strcmp(dp->d_name, ".."))
181			continue;
182			if (strlen(file) > dp->d_namlen)
183			continue;
184			if (strncmp(file, dp->d_name, strlen(file)) == 0) {
185			char *tcp;
186
187			tcp = strdup(dp->d_name);
188			if (tcp == NULL)
189			errx(1, "Can't allocate memory for local dir");
190			sl_add(words, tcp);
191			}
192			}
193			closedir(dd);
194
195			rv = complete_ambiguous(file, list, words);
196			sl_free(words, 1);
197			return (rv);
198			}
199
200			/*
201			* Complete a remote file
202			*/
203			static unsigned char
204			complete_remote(char *word, int list)
205			{
206			static StringList *dirlist;
207			static char lastdir[PATH_MAX];
208			StringList *words;
209			char dir[PATH_MAX];
210			char file, cp;
211			int i;
212			unsigned char rv;
213
214			char *dummyargv[] = { "complete", dir, NULL };
215
216			if ((file = strrchr(word, '/')) == NULL) {
217			dir[0] = '.';
218			dir[1] = '\0';
219			file = word;
220			} else {
221			cp = file;
222			while (*cp == '/' && cp > word)
223			cp--;
224			(void)strlcpy(dir, word, (size_t)(cp - word + 2));
225			file++;
226			}
227
228			if (dirchange \|\| strcmp(dir, lastdir) != 0) { /* dir not cached */
229			char *emesg;
230
231			sl_free(dirlist, 1);
232			dirlist = sl_init();
233
234			mflag = 1;
235			emesg = NULL;
236			if (debug)
237			(void)putc('\n', ttyout);
238			while ((cp = remglob(dummyargv, 0, &emesg)) != NULL) {
239			char *tcp;
240
241			if (!mflag)
242			continue;
243			if (*cp == '\0') {
244			mflag = 0;
245			continue;
246			}
247			tcp = strrchr(cp, '/');
248			if (tcp)
249			tcp++;
250			else
251			tcp = cp;
252			tcp = strdup(tcp);
253			if (tcp == NULL)
254			errx(1, "Can't allocate memory for remote dir");
255			sl_add(dirlist, tcp);
256			}
257			if (emesg != NULL) {
258			fprintf(ttyout, "\n%s\n", emesg);
259			return (CC_REDISPLAY);
260			}
261			(void)strlcpy(lastdir, dir, sizeof lastdir);
262			dirchange = 0;
263			}
264
265			words = sl_init();
266			for (i = 0; i < dirlist->sl_cur; i++) {
267			cp = dirlist->sl_str[i];
268			if (strlen(file) > strlen(cp))
269			continue;
270			if (strncmp(file, cp, strlen(file)) == 0)
271			sl_add(words, cp);
272			}
273			rv = complete_ambiguous(file, list, words);
274			sl_free(words, 0);
275			return (rv);
276			}
277
278			/*
279			* Generic complete routine
280			*/
281			unsigned char
282			complete(EditLine *el, int ch)
283			{
284			static char word[FTPBUFLEN];
285			static int lastc_argc, lastc_argo;
286			struct cmd *c;
287			const LineInfo *lf;
288			int celems, dolist;
289			size_t len;
290
291			ch = ch; /* not used */
292			lf = el_line(el);
293			len = lf->lastchar - lf->buffer;
294			if (len >= sizeof(line))
295			return (CC_ERROR);
296			(void)memcpy(line, lf->buffer, len);
297			line[len] = '\0';
298			cursor_pos = line + (lf->cursor - lf->buffer);
299			lastc_argc = cursor_argc; /* remember last cursor pos */
300			lastc_argo = cursor_argo;
301			makeargv(); /* build argc/argv of current line */
302
303			if (cursor_argo >= sizeof(word))
304			return (CC_ERROR);
305
306			dolist = 0;
307			/* if cursor and word is same, list alternatives */
308			if (lastc_argc == cursor_argc && lastc_argo == cursor_argo
309			&& strncmp(word, margv[cursor_argc], cursor_argo) == 0)
310			dolist = 1;
311			else if (cursor_argo)
312			memcpy(word, margv[cursor_argc], cursor_argo);
313			word[cursor_argo] = '\0';
314
315			if (cursor_argc == 0)
316			return (complete_command(word, dolist));
317
318			c = getcmd(margv[0]);
319			if (c == (struct cmd *)-1 \|\| c == 0)
320			return (CC_ERROR);
321			celems = strlen(c->c_complete);
322
323			/* check for 'continuation' completes (which are uppercase) */
324			if ((cursor_argc > celems) && (celems > 0)
325			&& isupper((unsigned char)c->c_complete[celems - 1]))
326			cursor_argc = celems;
327
328			if (cursor_argc > celems)
329			return (CC_ERROR);
330
331			switch (c->c_complete[cursor_argc - 1]) {
332			case 'l': /* local complete */
333			case 'L':
334			return (complete_local(word, dolist));
335			case 'r': /* remote complete */
336			case 'R':
337			if (connected != -1) {
338			fputs("\nMust be logged in to complete.\n", ttyout);
339			return (CC_REDISPLAY);
340			}
341			return (complete_remote(word, dolist));
342			case 'c': /* command complete */
343			case 'C':
344			return (complete_command(word, dolist));
345			case 'n': /* no complete */
346			return (CC_ERROR);
347			}
348
349			return (CC_ERROR);
350			}
351
352			/*
353			* Copy characters from src into dst, \ quoting characters that require it.
354			*/
355			static void
356			ftpvis(char dst, size_t dstlen, const char src, size_t srclen)
357			{
358			size_t di, si;
359
360			di = si = 0;
361			while (di + 1 < dstlen && si < srclen && src[si] != '\0') {
362			switch (src[si]) {
363			case '\\':
364			case ' ':
365			case '\t':
366			case '\r':
367			case '\n':
368			case '"':
369			/* Need room for two characters and NUL, avoiding
370			* incomplete escape sequences at end of dst. */
371			if (di + 3 >= dstlen)
372			break;
373			dst[di++] = '\\';
374			/* FALLTHROUGH */
375			default:
376			dst[di++] = src[si++];
377			}
378			}
379			if (dstlen != 0)
380			dst[di] = '\0';
381			}
382			#endif /* !SMALL */