Attachment #2701 for bug #2463




#ifdef HAVE_BSTRING_H
# include <bstring.h>
#endif
#include <glob.h>
    defined(GLOB_HAS_GL_MATCHC) && defined(GLOB_HAS_GL_STATV) && \
    defined(HAVE_DECL_GLOB_NOMATCH) &&  HAVE_DECL_GLOB_NOMATCH != 0 && \
    !defined(BROKEN_GLOB)
# include <glob.h>
#endif
#ifdef HAVE_ENDIAN_H
# include <endian.h>
#endif




#define	M_CLASS		META(':')
#define	ismeta(c)	(((c)&M_QUOTE) != 0)

#define	COMPAT_GLOB_LIMIT_MALLOC	65536
#define	COMPAT_GLOB_LIMIT_STAT		128
#define	COMPAT_GLOB_LIMIT_READDIR	16384

/* Limit of recursion during matching attempts. */
#define COMPAT_GLOB_LIMIT_RECUR	64

struct glob_lim {
	size_t	glim_malloc;

static int	 compare(const void *, const void *);
static int	 compare_gps(const void *, const void *);
static int	 g_Ctoc(const Char *, char *, u_int);
static int	 g_lstat(Char *, struct stat *, compat_glob_t *);
static DIR	*g_opendir(Char *, compat_glob_t *);
static Char	*g_strchr(const Char *, int);
static int	 g_strncmp(const Char *, const char *, size_t);
static int	 g_stat(Char *, struct stat *, compat_glob_t *);
static int	 glob0(const Char *, compat_glob_t *, struct glob_lim *);
static int	 glob1(Char *, Char *, compat_glob_t *, struct glob_lim *);
static int	 glob2(Char *, Char *, Char *, Char *, Char *, Char *,
		    compat_glob_t *, struct glob_lim *);
static int	 glob3(Char *, Char *, Char *, Char *, Char *,
		    Char *, Char *, compat_glob_t *, struct glob_lim *);
static int	 globextend(const Char *, compat_glob_t *, struct glob_lim *,
		    struct stat *);
static const Char *
		 globtilde(const Char *, Char *, size_t, compat_glob_t *);
static int	 globexp1(const Char *, compat_glob_t *, struct glob_lim *);
static int	 globexp2(const Char *, const Char *, compat_glob_t *,
		    struct glob_lim *);
static int	 match(Char *, Char *, Char *, int);
#ifdef DEBUG

#endif

int
compat_glob(const char *pattern, int flags, int (*errfunc)(const char *, int),
    compat_glob_t *pglob)
{
	const u_char *patnext;
	int c;

	struct glob_lim limit = { 0, 0, 0 };

	if (strnlen(pattern, PATH_MAX) == PATH_MAX)
		return(COMPAT_GLOB_NOMATCH);

	patnext = (u_char *) pattern;
	if (!(flags & COMPAT_GLOB_APPEND)) {
		pglob->gl_pathc = 0;
		pglob->gl_pathv = NULL;
		pglob->gl_statv = NULL;
		if (!(flags & COMPAT_GLOB_DOOFFS))
			pglob->gl_offs = 0;
	}
	pglob->gl_flags = flags & ~COMPAT_GLOB_MAGCHAR;
	pglob->gl_errfunc = errfunc;
	pglob->gl_matchc = 0;

	if (pglob->gl_offs < 0 || pglob->gl_pathc < 0 ||
	    pglob->gl_offs >= INT_MAX || pglob->gl_pathc >= INT_MAX ||
	    pglob->gl_pathc >= INT_MAX - pglob->gl_offs - 1)
		return COMPAT_GLOB_NOSPACE;

	bufnext = patbuf;
	bufend = bufnext + MAXPATHLEN - 1;
	if (flags & COMPAT_GLOB_NOESCAPE)
		while (bufnext < bufend && (c = *patnext++) != EOS)
			*bufnext++ = c;
	else {

	}
	*bufnext = EOS;

	if (flags & COMPAT_GLOB_BRACE)
		return globexp1(patbuf, pglob, &limit);
	else
		return glob0(patbuf, pglob, &limit);

 * characters
 */
static int
globexp1(const Char *pattern, compat_glob_t *pglob, struct glob_lim *limitp)
{
	const Char* ptr = pattern;


 * If it fails then it tries to glob the rest of the pattern and returns.
 */
static int
globexp2(const Char *ptr, const Char *pattern, compat_glob_t *pglob,
    struct glob_lim *limitp)
{
	int     i, rv;

				qprintf("globexp2:", patbuf);
#endif
				rv = globexp1(patbuf, pglob, limitp);
				if (rv && rv != COMPAT_GLOB_NOMATCH)
					return rv;

				/* move after the comma, to the next string */

 * expand tilde from the passwd file.
 */
static const Char *
globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, compat_glob_t *pglob)
{
	struct passwd *pwd;
	char *h;
	const Char *p;
	Char *b, *eb;

	if (*pattern != TILDE || !(pglob->gl_flags & COMPAT_GLOB_TILDE))
		return pattern;

	/* Copy up to the end of the string or / */

 * to find no matches.
 */
static int
glob0(const Char *pattern, compat_glob_t *pglob, struct glob_lim *limitp)
{
	const Char *qpatnext;
	int c, err, oldpathc;

						c = *qpatnext++;
					} while (c == LBRACKET && *qpatnext == ':');
					if (err == -1 &&
					    !(pglob->gl_flags & COMPAT_GLOB_NOCHECK))
						return COMPAT_GLOB_NOMATCH;
					if (c == RBRACKET)
						break;
				}

					qpatnext += 2;
				}
			} while ((c = *qpatnext++) != RBRACKET);
			pglob->gl_flags |= COMPAT_GLOB_MAGCHAR;
			*bufnext++ = M_END;
			break;
		case QUESTION:
			pglob->gl_flags |= COMPAT_GLOB_MAGCHAR;
			*bufnext++ = M_ONE;
			break;
		case STAR:
			pglob->gl_flags |= COMPAT_GLOB_MAGCHAR;
			/* collapse adjacent stars to one,
			 * to avoid exponential behavior
			 */

	 * GLOB_NOMAGIC is there just for compatibility with csh.
	 */
	if (pglob->gl_pathc == oldpathc) {
		if ((pglob->gl_flags & COMPAT_GLOB_NOCHECK) ||
		    ((pglob->gl_flags & COMPAT_GLOB_NOMAGIC) &&
		    !(pglob->gl_flags & COMPAT_GLOB_MAGCHAR)))
			return(globextend(pattern, pglob, limitp, NULL));
		else
			return(COMPAT_GLOB_NOMATCH);
	}
	if (!(pglob->gl_flags & COMPAT_GLOB_NOSORT)) {
		if ((pglob->gl_flags & COMPAT_GLOB_KEEPSTAT)) {
			/* Keep the paths and stat info synced during sort */
			struct glob_path_stat *path_stat;
			int i;

			int o = pglob->gl_offs + oldpathc;

			if ((path_stat = calloc(n, sizeof(*path_stat))) == NULL)
				return COMPAT_GLOB_NOSPACE;
			for (i = 0; i < n; i++) {
				path_stat[i].gps_path = pglob->gl_pathv[o + i];
				path_stat[i].gps_stat = pglob->gl_statv[o + i];

}

static int
glob1(Char *pattern, Char *pattern_last, compat_glob_t *pglob, struct glob_lim *limitp)
{
	Char pathbuf[MAXPATHLEN];


 */
static int
glob2(Char *pathbuf, Char *pathbuf_last, Char *pathend, Char *pathend_last,
    Char *pattern, Char *pattern_last, compat_glob_t *pglob, struct glob_lim *limitp)
{
	struct stat sb;
	Char *p, *q;

			if (g_lstat(pathbuf, &sb, pglob))
				return(0);

			if ((pglob->gl_flags & COMPAT_GLOB_LIMIT) &&
			    limitp->glim_stat++ >= COMPAT_GLOB_LIMIT_STAT) {
				errno = 0;
				*pathend++ = SEP;
				*pathend = EOS;
				return(COMPAT_GLOB_NOSPACE);
			}

			if (((pglob->gl_flags & COMPAT_GLOB_MARK) &&
			    pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||
			    (S_ISLNK(sb.st_mode) &&
			    (g_stat(pathbuf, &sb, pglob) == 0) &&


static int
glob3(Char *pathbuf, Char *pathbuf_last, Char *pathend, Char *pathend_last,
    Char *pattern, Char *restpattern, Char *restpattern_last, compat_glob_t *pglob,
    struct glob_lim *limitp)
{
	struct dirent *dp;

		/* TODO: don't call for ENOENT or ENOTDIR? */
		if (pglob->gl_errfunc) {
			if (g_Ctoc(pathbuf, buf, sizeof(buf)))
				return(COMPAT_GLOB_ABORTED);
			if (pglob->gl_errfunc(buf, errno) ||
			    pglob->gl_flags & COMPAT_GLOB_ERR)
				return(COMPAT_GLOB_ABORTED);
		}
		return(0);
	}

	err = 0;

	/* Search directory for matching names. */
	if (pglob->gl_flags & COMPAT_GLOB_ALTDIRFUNC)
		readdirfunc = pglob->gl_readdir;
	else
		readdirfunc = (struct dirent *(*)(void *))readdir;

		u_char *sc;
		Char *dc;

		if ((pglob->gl_flags & COMPAT_GLOB_LIMIT) &&
		    limitp->glim_readdir++ >= COMPAT_GLOB_LIMIT_READDIR) {
			errno = 0;
			*pathend++ = SEP;
			*pathend = EOS;
			err = COMPAT_GLOB_NOSPACE;
			break;
		}


			break;
		}

		if (!match(pathend, pattern, restpattern, COMPAT_GLOB_LIMIT_RECUR)) {
			*pathend = EOS;
			continue;
		}

			break;
	}

	if (pglob->gl_flags & COMPAT_GLOB_ALTDIRFUNC)
		(*pglob->gl_closedir)(dirp);
	else
		closedir(dirp);

 *	gl_pathv points to (gl_offs + gl_pathc + 1) items.
 */
static int
globextend(const Char *path, compat_glob_t *pglob, struct glob_lim *limitp,
    struct stat *sb)
{
	char **pathv;

		for (i = pglob->gl_offs; i < (ssize_t)(newn - 2); i++) {
			if (pglob->gl_pathv && pglob->gl_pathv[i])
				free(pglob->gl_pathv[i]);
			if ((pglob->gl_flags & COMPAT_GLOB_KEEPSTAT) != 0 &&
			    pglob->gl_pathv && pglob->gl_pathv[i])
				free(pglob->gl_statv[i]);
		}

			free(pglob->gl_statv);
			pglob->gl_statv = NULL;
		}
		return(COMPAT_GLOB_NOSPACE);
	}

	pathv = realloc(pglob->gl_pathv, newn * sizeof(*pathv));

	}
	pglob->gl_pathv = pathv;

	if ((pglob->gl_flags & COMPAT_GLOB_KEEPSTAT) != 0) {
		statv = realloc(pglob->gl_statv, newn * sizeof(*statv));
		if (statv == NULL)
			goto nospace;

			statv[pglob->gl_offs + pglob->gl_pathc] = NULL;
		else {
			limitp->glim_malloc += sizeof(**statv);
			if ((pglob->gl_flags & COMPAT_GLOB_LIMIT) &&
			    limitp->glim_malloc >= COMPAT_GLOB_LIMIT_MALLOC) {
				errno = 0;
				return(COMPAT_GLOB_NOSPACE);
			}
			if ((statv[pglob->gl_offs + pglob->gl_pathc] =
			    malloc(sizeof(**statv))) == NULL)

	if ((copy = malloc(len)) != NULL) {
		if (g_Ctoc(path, copy, len)) {
			free(copy);
			return(COMPAT_GLOB_NOSPACE);
		}
		pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
	}
	pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;

	if ((pglob->gl_flags & COMPAT_GLOB_LIMIT) &&
	    (newn * sizeof(*pathv)) + limitp->glim_malloc >
	    COMPAT_GLOB_LIMIT_MALLOC) {
		errno = 0;
		return(COMPAT_GLOB_NOSPACE);
	}
 copy_error:
	return(copy == NULL ? COMPAT_GLOB_NOSPACE : 0);
}



	Char c, k;

	if (recur-- == 0)
		return(COMPAT_GLOB_NOSPACE);

	while (pat < patend) {
		c = *pat++;


/* Free allocated data belonging to a glob_t structure. */
void
compat_globfree(compat_glob_t *pglob)
{
	int i;
	char **pp;

}

static DIR *
g_opendir(Char *str, compat_glob_t *pglob)
{
	char buf[MAXPATHLEN];


			return(NULL);
	}

	if (pglob->gl_flags & COMPAT_GLOB_ALTDIRFUNC)
		return((*pglob->gl_opendir)(buf));

	return(opendir(buf));
}

static int
g_lstat(Char *fn, struct stat *sb, compat_glob_t *pglob)
{
	char buf[MAXPATHLEN];

	if (g_Ctoc(fn, buf, sizeof(buf)))
		return(-1);
	if (pglob->gl_flags & COMPAT_GLOB_ALTDIRFUNC)
		return((*pglob->gl_lstat)(buf, sb));
	return(lstat(buf, sb));
}

static int
g_stat(Char *fn, struct stat *sb, compat_glob_t *pglob)
{
	char buf[MAXPATHLEN];

	if (g_Ctoc(fn, buf, sizeof(buf)))
		return(-1);
	if (pglob->gl_flags & COMPAT_GLOB_ALTDIRFUNC)
		return((*pglob->gl_stat)(buf, sb));
	return(stat(buf, sb));
}




    !defined(HAVE_DECL_GLOB_NOMATCH) || HAVE_DECL_GLOB_NOMATCH == 0 || \
    defined(BROKEN_GLOB)

#ifndef _COMPAT_GLOB_H_
#define	_COMPAT_GLOB_H_

#include <sys/stat.h>


	void *(*gl_opendir)(const char *);
	int (*gl_lstat)(const char *, struct stat *);
	int (*gl_stat)(const char *, struct stat *);
} compat_glob_t;

#define	COMPAT_GLOB_APPEND	0x0001	/* Append to output from previous call. */
#define	COMPAT_GLOB_DOOFFS	0x0002	/* Use gl_offs. */
#define	COMPAT_GLOB_ERR	0x0004	/* Return on error. */
#define	COMPAT_GLOB_MARK	0x0008	/* Append / to matching directories. */
#define	COMPAT_GLOB_NOCHECK	0x0010	/* Return pattern itself if nothing matches. */
#define	COMPAT_GLOB_NOSORT	0x0020	/* Don't sort. */
#define	COMPAT_GLOB_NOESCAPE	0x1000	/* Disable backslash escaping. */

#define	COMPAT_GLOB_NOSPACE	(-1)	/* Malloc call failed. */
#define	COMPAT_GLOB_ABORTED	(-2)	/* Unignored error. */
#define	COMPAT_GLOB_NOMATCH	(-3)	/* No match and GLOB_NOCHECK not set. */
#define	COMPAT_GLOB_NOSYS	(-4)	/* Function not supported. */

#define	COMPAT_GLOB_ALTDIRFUNC	0x0040	/* Use alternately specified directory funcs. */
#define	COMPAT_GLOB_BRACE	0x0080	/* Expand braces ala csh. */
#define	COMPAT_GLOB_MAGCHAR	0x0100	/* Pattern had globbing characters. */
#define	COMPAT_GLOB_NOMAGIC	0x0200	/* GLOB_NOCHECK without magic chars (csh). */
#define	COMPAT_GLOB_QUOTE	0x0400	/* Quote special chars with \. */
#define	COMPAT_GLOB_TILDE	0x0800	/* Expand tilde names from the passwd file. */
#define COMPAT_GLOB_LIMIT	0x2000	/* Limit pattern match output to ARG_MAX */
#define	COMPAT_GLOB_KEEPSTAT	0x4000	/* Retain stat data for paths in gl_statv. */
#define COMPAT_GLOB_ABEND	COMPAT_GLOB_ABORTED /* backward compatibility */

int	compat_glob(const char *, int, int (*)(const char *, int), compat_glob_t *);
void	compat_globfree(compat_glob_t *);

#endif /* !_COMPAT_GLOB_H_ */

#endif /* !defined(HAVE_GLOB_H) || !defined(GLOB_HAS_ALTDIRFUNC)  ||
	  !defined(GLOB_HAS_GL_MATCHC) || !defined(GLOH_HAS_GL_STATV) */

Lines 33-39 Link Here

(-)a/sftp-glob.c (-3 / +3 lines)
33	#include "sftp-client.h"	33	#include "sftp-client.h"
34		34
35	int remote_glob(struct sftp_conn , const char , int,	35	int remote_glob(struct sftp_conn , const char , int,
36	int ()(const char , int), glob_t *);	36	int ()(const char , int), compat_glob_t *);
37		37
38	struct SFTP_OPENDIR {	38	struct SFTP_OPENDIR {
39	SFTP_DIRENT **dir;	39	SFTP_DIRENT **dir;
Lines 135-141 fudge_stat(const char path, struct stat st) Link Here
135		135
136	int	136	int
137	remote_glob(struct sftp_conn conn, const char pattern, int flags,	137	remote_glob(struct sftp_conn conn, const char pattern, int flags,
138	int (errfunc)(const char , int), glob_t *pglob)	138	int (errfunc)(const char , int), compat_glob_t *pglob)
139	{	139	{
140	pglob->gl_opendir = fudge_opendir;	140	pglob->gl_opendir = fudge_opendir;
141	pglob->gl_readdir = (struct dirent ()(void *))fudge_readdir;	141	pglob->gl_readdir = (struct dirent ()(void *))fudge_readdir;
Lines 146-150 remote_glob(struct sftp_conn conn, const char pattern, int flags, Link Here
146	memset(&cur, 0, sizeof(cur));	146	memset(&cur, 0, sizeof(cur));
147	cur.conn = conn;	147	cur.conn = conn;
148		148
149	return(glob(pattern, flags \| GLOB_ALTDIRFUNC, errfunc, pglob));	149	return(compat_glob(pattern, flags \| COMPAT_GLOB_ALTDIRFUNC, errfunc, pglob));
150	}	150	}




};

int remote_glob(struct sftp_conn *, const char *, int,
    int (*)(const char *, int), compat_glob_t *); /* proto for sftp-glob.c */

extern char *__progname;


{
	char *abs_src = NULL;
	char *abs_dst = NULL;
	compat_glob_t g;
	char *filename, *tmp=NULL;
	int i, r, err = 0;


	memset(&g, 0, sizeof(g));

	debug3("Looking up %s", abs_src);
	if ((r = remote_glob(conn, abs_src, COMPAT_GLOB_MARK, NULL, &g)) != 0) {
		if (r == COMPAT_GLOB_NOSPACE) {
			error("Too many matches for \"%s\".", abs_src);
		} else {
			error("File \"%s\" not found.", abs_src);


out:
	free(abs_src);
	compat_globfree(&g);
	return(err);
}


	char *tmp_dst = NULL;
	char *abs_dst = NULL;
	char *tmp = NULL, *filename = NULL;
	compat_glob_t g;
	int err = 0;
	int i, dst_is_dir = 1;
	struct stat sb;


	memset(&g, 0, sizeof(g));
	debug3("Looking up %s", src);
	if (compat_glob(src, GLOB_NOCHECK | GLOB_MARK, NULL, &g)) {
		error("File \"%s\" not found.", src);
		err = -1;
		goto out;

out:
	free(abs_dst);
	free(tmp_dst);
	compat_globfree(&g);
	return(err);
}


    int lflag)
{
	char *fname, *lname;
	compat_glob_t g;
	int err, r;
	struct winsize ws;
	u_int i, c = 1, colspace = 0, columns = 1, m = 0, width = 80;

	memset(&g, 0, sizeof(g));

	if ((r = remote_glob(conn, path,COMPAT_GLOB_MARK|COMPAT_GLOB_NOCHECK|
	    COMPAT_GLOB_BRACE|COMPAT_GLOB_KEEPSTAT|COMPAT_GLOB_NOSORT,
	    NULL, &g)) != 0 ||
	    (g.gl_pathc && !g.gl_matchc)) {
		if (g.gl_pathc)
			compat_globfree(&g);
		if (r == COMPAT_GLOB_NOSPACE) {
			error("Can't ls: Too many matches for \"%s\"", path);
		} else {
			error("Can't ls: \"%s\" not found", path);

	if (g.gl_matchc == 1 && g.gl_statv[0] != NULL &&
	    S_ISDIR(g.gl_statv[0]->st_mode)) {
		err = do_ls_dir(conn, g.gl_pathv[0], strip_path, lflag);
		compat_globfree(&g);
		return err;
	}



 out:
	if (g.gl_pathc)
		compat_globfree(&g);

	return 0;
}

	Attrib a, *aa;
	char path_buf[PATH_MAX];
	int err = 0;
	compat_glob_t g;

	path1 = path2 = NULL;
	cmdnum = parse_args(&cmd, &ignore_errors, &aflag, &fflag, &hflag,

		break;
	case I_RM:
		path1 = make_absolute(path1, *pwd);
		remote_glob(conn, path1, COMPAT_GLOB_NOCHECK, NULL, &g);
		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
			if (!quiet)
				printf("Removing %s\n", g.gl_pathv[i]);

		attrib_clear(&a);
		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
		a.perm = n_arg;
		remote_glob(conn, path1, COMPAT_GLOB_NOCHECK, NULL, &g);
		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
			if (!quiet)
				printf("Changing mode on %s\n", g.gl_pathv[i]);

	case I_CHOWN:
	case I_CHGRP:
		path1 = make_absolute(path1, *pwd);
		remote_glob(conn, path1, COMPAT_GLOB_NOCHECK, NULL, &g);
		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
			if (!(aa = do_stat(conn, g.gl_pathv[i], 0))) {
				if (err_abort) {

	}

	if (g.gl_pathc)
		compat_globfree(&g);
	free(path1);
	free(path2);


complete_match(EditLine *el, struct sftp_conn *conn, char *remote_path,
    char *file, int remote, int lastarg, char quote, int terminated)
{
	compat_glob_t g;
	char *tmp, *tmp2, ins[8];
	u_int i, hadglob, pwdlen, len, tmplen, filelen, cesc, isesc, isabs;
	int clen;

	memset(&g, 0, sizeof(g));
	if (remote != LOCAL) {
		tmp = make_absolute(tmp, remote_path);
		remote_glob(conn, tmp, COMPAT_GLOB_DOOFFS|COMPAT_GLOB_MARK, NULL, &g);
	} else
		compat_glob(tmp, COMPAT_GLOB_DOOFFS|COMPAT_GLOB_MARK, NULL, &g);

	/* Determine length of pwd so we can trim completion display */
	for (hadglob = tmplen = pwdlen = 0; tmp[tmplen] != 0; tmplen++) {

	free(tmp);

 out:
	compat_globfree(&g);
	return g.gl_matchc;
}

- 

Return to bug 2463

Lines 113-119 struct complete_ctx { Link Here

(-)a/sftp.c (-25 / +24 lines)
113	};	113	};
114		114
115	int remote_glob(struct sftp_conn , const char , int,	115	int remote_glob(struct sftp_conn , const char , int,
116	int ()(const char , int), glob_t ); / proto for sftp-glob.c */	116	int ()(const char , int), compat_glob_t ); / proto for sftp-glob.c */
117		117
118	extern char *__progname;	118	extern char *__progname;
119		119
Lines 590-596 process_get(struct sftp_conn conn, char src, char dst, char pwd, Link Here
590	{	590	{
591	char *abs_src = NULL;	591	char *abs_src = NULL;
592	char *abs_dst = NULL;	592	char *abs_dst = NULL;
593	glob_t g;	593	compat_glob_t g;
594	char filename, tmp=NULL;	594	char filename, tmp=NULL;
595	int i, r, err = 0;	595	int i, r, err = 0;
596		596
Lines 599-606 process_get(struct sftp_conn conn, char src, char dst, char pwd, Link Here
599	memset(&g, 0, sizeof(g));	599	memset(&g, 0, sizeof(g));
600		600
601	debug3("Looking up %s", abs_src);	601	debug3("Looking up %s", abs_src);
602	if ((r = remote_glob(conn, abs_src, GLOB_MARK, NULL, &g)) != 0) {	602	if ((r = remote_glob(conn, abs_src, COMPAT_GLOB_MARK, NULL, &g)) != 0) {
603	if (r == GLOB_NOSPACE) {	603	if (r == COMPAT_GLOB_NOSPACE) {
604	error("Too many matches for \"%s\".", abs_src);	604	error("Too many matches for \"%s\".", abs_src);
605	} else {	605	} else {
606	error("File \"%s\" not found.", abs_src);	606	error("File \"%s\" not found.", abs_src);
Lines 664-670 process_get(struct sftp_conn conn, char src, char dst, char pwd, Link Here
664		664
665	out:	665	out:
666	free(abs_src);	666	free(abs_src);
667	globfree(&g);	667	compat_globfree(&g);
668	return(err);	668	return(err);
669	}	669	}
670		670
Lines 675-681 process_put(struct sftp_conn conn, char src, char dst, char pwd, Link Here
675	char *tmp_dst = NULL;	675	char *tmp_dst = NULL;
676	char *abs_dst = NULL;	676	char *abs_dst = NULL;
677	char tmp = NULL, filename = NULL;	677	char tmp = NULL, filename = NULL;
678	glob_t g;	678	compat_glob_t g;
679	int err = 0;	679	int err = 0;
680	int i, dst_is_dir = 1;	680	int i, dst_is_dir = 1;
681	struct stat sb;	681	struct stat sb;
Lines 687-693 process_put(struct sftp_conn conn, char src, char dst, char pwd, Link Here
687		687
688	memset(&g, 0, sizeof(g));	688	memset(&g, 0, sizeof(g));
689	debug3("Looking up %s", src);	689	debug3("Looking up %s", src);
690	if (glob(src, GLOB_NOCHECK \| GLOB_MARK, NULL, &g)) {	690	if (compat_glob(src, GLOB_NOCHECK \| GLOB_MARK, NULL, &g)) {
691	error("File \"%s\" not found.", src);	691	error("File \"%s\" not found.", src);
692	err = -1;	692	err = -1;
693	goto out;	693	goto out;
Lines 755-761 process_put(struct sftp_conn conn, char src, char dst, char pwd, Link Here
755	out:	755	out:
756	free(abs_dst);	756	free(abs_dst);
757	free(tmp_dst);	757	free(tmp_dst);
758	globfree(&g);	758	compat_globfree(&g);
759	return(err);	759	return(err);
760	}	760	}
761		761
Lines 868-887 do_globbed_ls(struct sftp_conn conn, char path, char *strip_path, Link Here
868	int lflag)	868	int lflag)
869	{	869	{
870	char fname, lname;	870	char fname, lname;
871	glob_t g;	871	compat_glob_t g;
872	int err, r;	872	int err, r;
873	struct winsize ws;	873	struct winsize ws;
874	u_int i, c = 1, colspace = 0, columns = 1, m = 0, width = 80;	874	u_int i, c = 1, colspace = 0, columns = 1, m = 0, width = 80;
875		875
876	memset(&g, 0, sizeof(g));	876	memset(&g, 0, sizeof(g));
877		877
878	if ((r = remote_glob(conn, path,	878	if ((r = remote_glob(conn, path,COMPAT_GLOB_MARK\|COMPAT_GLOB_NOCHECK\|
879	GLOB_MARK\|GLOB_NOCHECK\|GLOB_BRACE\|GLOB_KEEPSTAT\|GLOB_NOSORT,	879	COMPAT_GLOB_BRACE\|COMPAT_GLOB_KEEPSTAT\|COMPAT_GLOB_NOSORT,
880	NULL, &g)) != 0 \|\|	880	NULL, &g)) != 0 \|\|
881	(g.gl_pathc && !g.gl_matchc)) {	881	(g.gl_pathc && !g.gl_matchc)) {
882	if (g.gl_pathc)	882	if (g.gl_pathc)
883	globfree(&g);	883	compat_globfree(&g);
884	if (r == GLOB_NOSPACE) {	884	if (r == COMPAT_GLOB_NOSPACE) {
885	error("Can't ls: Too many matches for \"%s\"", path);	885	error("Can't ls: Too many matches for \"%s\"", path);
886	} else {	886	} else {
887	error("Can't ls: \"%s\" not found", path);	887	error("Can't ls: \"%s\" not found", path);
Lines 899-905 do_globbed_ls(struct sftp_conn conn, char path, char *strip_path, Link Here
899	if (g.gl_matchc == 1 && g.gl_statv[0] != NULL &&	899	if (g.gl_matchc == 1 && g.gl_statv[0] != NULL &&
900	S_ISDIR(g.gl_statv[0]->st_mode)) {	900	S_ISDIR(g.gl_statv[0]->st_mode)) {
901	err = do_ls_dir(conn, g.gl_pathv[0], strip_path, lflag);	901	err = do_ls_dir(conn, g.gl_pathv[0], strip_path, lflag);
902	globfree(&g);	902	compat_globfree(&g);
903	return err;	903	return err;
904	}	904	}
905		905
Lines 943-949 do_globbed_ls(struct sftp_conn conn, char path, char *strip_path, Link Here
943		943
944	out:	944	out:
945	if (g.gl_pathc)	945	if (g.gl_pathc)
946	globfree(&g);	946	compat_globfree(&g);
947		947
948	return 0;	948	return 0;
949	}	949	}
Lines 1405-1411 parse_dispatch_command(struct sftp_conn conn, const char cmd, char **pwd, Link Here
1405	Attrib a, *aa;	1405	Attrib a, *aa;
1406	char path_buf[PATH_MAX];	1406	char path_buf[PATH_MAX];
1407	int err = 0;	1407	int err = 0;
1408	glob_t g;	1408	compat_glob_t g;
1409		1409
1410	path1 = path2 = NULL;	1410	path1 = path2 = NULL;
1411	cmdnum = parse_args(&cmd, &ignore_errors, &aflag, &fflag, &hflag,	1411	cmdnum = parse_args(&cmd, &ignore_errors, &aflag, &fflag, &hflag,
Lines 1453-1459 parse_dispatch_command(struct sftp_conn conn, const char cmd, char **pwd, Link Here
1453	break;	1453	break;
1454	case I_RM:	1454	case I_RM:
1455	path1 = make_absolute(path1, *pwd);	1455	path1 = make_absolute(path1, *pwd);
1456	remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);	1456	remote_glob(conn, path1, COMPAT_GLOB_NOCHECK, NULL, &g);
1457	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {	1457	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1458	if (!quiet)	1458	if (!quiet)
1459	printf("Removing %s\n", g.gl_pathv[i]);	1459	printf("Removing %s\n", g.gl_pathv[i]);
Lines 1553-1559 parse_dispatch_command(struct sftp_conn conn, const char cmd, char **pwd, Link Here
1553	attrib_clear(&a);	1553	attrib_clear(&a);
1554	a.flags \|= SSH2_FILEXFER_ATTR_PERMISSIONS;	1554	a.flags \|= SSH2_FILEXFER_ATTR_PERMISSIONS;
1555	a.perm = n_arg;	1555	a.perm = n_arg;
1556	remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);	1556	remote_glob(conn, path1, COMPAT_GLOB_NOCHECK, NULL, &g);
1557	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {	1557	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1558	if (!quiet)	1558	if (!quiet)
1559	printf("Changing mode on %s\n", g.gl_pathv[i]);	1559	printf("Changing mode on %s\n", g.gl_pathv[i]);
Lines 1565-1571 parse_dispatch_command(struct sftp_conn conn, const char cmd, char **pwd, Link Here
1565	case I_CHOWN:	1565	case I_CHOWN:
1566	case I_CHGRP:	1566	case I_CHGRP:
1567	path1 = make_absolute(path1, *pwd);	1567	path1 = make_absolute(path1, *pwd);
1568	remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);	1568	remote_glob(conn, path1, COMPAT_GLOB_NOCHECK, NULL, &g);
1569	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {	1569	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1570	if (!(aa = do_stat(conn, g.gl_pathv[i], 0))) {	1570	if (!(aa = do_stat(conn, g.gl_pathv[i], 0))) {
1571	if (err_abort) {	1571	if (err_abort) {
Lines 1632-1638 parse_dispatch_command(struct sftp_conn conn, const char cmd, char **pwd, Link Here
1632	}	1632	}
1633		1633
1634	if (g.gl_pathc)	1634	if (g.gl_pathc)
1635	globfree(&g);	1635	compat_globfree(&g);
1636	free(path1);	1636	free(path1);
1637	free(path2);	1637	free(path2);
1638		1638
Lines 1820-1826 static int Link Here
1820	complete_match(EditLine el, struct sftp_conn conn, char *remote_path,	1820	complete_match(EditLine el, struct sftp_conn conn, char *remote_path,
1821	char *file, int remote, int lastarg, char quote, int terminated)	1821	char *file, int remote, int lastarg, char quote, int terminated)
1822	{	1822	{
1823	glob_t g;	1823	compat_glob_t g;
1824	char tmp, tmp2, ins[8];	1824	char tmp, tmp2, ins[8];
1825	u_int i, hadglob, pwdlen, len, tmplen, filelen, cesc, isesc, isabs;	1825	u_int i, hadglob, pwdlen, len, tmplen, filelen, cesc, isesc, isabs;
1826	int clen;	1826	int clen;
Lines 1838-1846 complete_match(EditLine el, struct sftp_conn conn, char *remote_path, Link Here
1838	memset(&g, 0, sizeof(g));	1838	memset(&g, 0, sizeof(g));
1839	if (remote != LOCAL) {	1839	if (remote != LOCAL) {
1840	tmp = make_absolute(tmp, remote_path);	1840	tmp = make_absolute(tmp, remote_path);
1841	remote_glob(conn, tmp, GLOB_DOOFFS\|GLOB_MARK, NULL, &g);	1841	remote_glob(conn, tmp, COMPAT_GLOB_DOOFFS\|COMPAT_GLOB_MARK, NULL, &g);
1842	} else	1842	} else
1843	glob(tmp, GLOB_DOOFFS\|GLOB_MARK, NULL, &g);	1843	compat_glob(tmp, COMPAT_GLOB_DOOFFS\|COMPAT_GLOB_MARK, NULL, &g);
1844		1844
1845	/* Determine length of pwd so we can trim completion display */	1845	/* Determine length of pwd so we can trim completion display */
1846	for (hadglob = tmplen = pwdlen = 0; tmp[tmplen] != 0; tmplen++) {	1846	for (hadglob = tmplen = pwdlen = 0; tmp[tmplen] != 0; tmplen++) {
Lines 1938-1944 complete_match(EditLine el, struct sftp_conn conn, char *remote_path, Link Here
1938	free(tmp);	1938	free(tmp);
1939		1939
1940	out:	1940	out:
1941	globfree(&g);	1941	compat_globfree(&g);
1942	return g.gl_matchc;	1942	return g.gl_matchc;
1943	}	1943	}
1944		1944
1945	-

Lines 32-43 Link Here

(-)a/includes.h (-6 / +1 lines)
32	#ifdef HAVE_BSTRING_H	32	#ifdef HAVE_BSTRING_H
33	# include <bstring.h>	33	# include <bstring.h>
34	#endif	34	#endif
35	#if defined(HAVE_GLOB_H) && defined(GLOB_HAS_ALTDIRFUNC) && \	35	#include <glob.h>
36	defined(GLOB_HAS_GL_MATCHC) && defined(GLOB_HAS_GL_STATV) && \
37	defined(HAVE_DECL_GLOB_NOMATCH) && HAVE_DECL_GLOB_NOMATCH != 0 && \
38	!defined(BROKEN_GLOB)
39	# include <glob.h>
40	#endif
41	#ifdef HAVE_ENDIAN_H	36	#ifdef HAVE_ENDIAN_H
42	# include <endian.h>	37	# include <endian.h>
43	#endif	38	#endif

Lines 42-49 Link Here

(-)a/openbsd-compat/glob.h (-26 / +26 lines)
42	!defined(HAVE_DECL_GLOB_NOMATCH) \|\| HAVE_DECL_GLOB_NOMATCH == 0 \|\| \	42	!defined(HAVE_DECL_GLOB_NOMATCH) \|\| HAVE_DECL_GLOB_NOMATCH == 0 \|\| \
43	defined(BROKEN_GLOB)	43	defined(BROKEN_GLOB)
44		44
45	#ifndef _GLOB_H_	45	#ifndef _COMPAT_GLOB_H_
46	#define _GLOB_H_	46	#define _COMPAT_GLOB_H_
47		47
48	#include <sys/stat.h>	48	#include <sys/stat.h>
49		49
Lines 68-102 typedef struct { Link Here
68	void (gl_opendir)(const char *);	68	void (gl_opendir)(const char *);
69	int (gl_lstat)(const char , struct stat *);	69	int (gl_lstat)(const char , struct stat *);
70	int (gl_stat)(const char , struct stat *);	70	int (gl_stat)(const char , struct stat *);
71	} glob_t;	71	} compat_glob_t;
72		72
73	#define GLOB_APPEND 0x0001 /* Append to output from previous call. */	73	#define COMPAT_GLOB_APPEND 0x0001 /* Append to output from previous call. */
74	#define GLOB_DOOFFS 0x0002 /* Use gl_offs. */	74	#define COMPAT_GLOB_DOOFFS 0x0002 /* Use gl_offs. */
75	#define GLOB_ERR 0x0004 /* Return on error. */	75	#define COMPAT_GLOB_ERR 0x0004 /* Return on error. */
76	#define GLOB_MARK 0x0008 /* Append / to matching directories. */	76	#define COMPAT_GLOB_MARK 0x0008 /* Append / to matching directories. */
77	#define GLOB_NOCHECK 0x0010 /* Return pattern itself if nothing matches. */	77	#define COMPAT_GLOB_NOCHECK 0x0010 /* Return pattern itself if nothing matches. */
78	#define GLOB_NOSORT 0x0020 /* Don't sort. */	78	#define COMPAT_GLOB_NOSORT 0x0020 /* Don't sort. */
79	#define GLOB_NOESCAPE 0x1000 /* Disable backslash escaping. */	79	#define COMPAT_GLOB_NOESCAPE 0x1000 /* Disable backslash escaping. */
80		80
81	#define GLOB_NOSPACE (-1) /* Malloc call failed. */	81	#define COMPAT_GLOB_NOSPACE (-1) /* Malloc call failed. */
82	#define GLOB_ABORTED (-2) /* Unignored error. */	82	#define COMPAT_GLOB_ABORTED (-2) /* Unignored error. */
83	#define GLOB_NOMATCH (-3) /* No match and GLOB_NOCHECK not set. */	83	#define COMPAT_GLOB_NOMATCH (-3) /* No match and GLOB_NOCHECK not set. */
84	#define GLOB_NOSYS (-4) /* Function not supported. */	84	#define COMPAT_GLOB_NOSYS (-4) /* Function not supported. */
85		85
86	#define GLOB_ALTDIRFUNC 0x0040 /* Use alternately specified directory funcs. */	86	#define COMPAT_GLOB_ALTDIRFUNC 0x0040 /* Use alternately specified directory funcs. */
87	#define GLOB_BRACE 0x0080 /* Expand braces ala csh. */	87	#define COMPAT_GLOB_BRACE 0x0080 /* Expand braces ala csh. */
88	#define GLOB_MAGCHAR 0x0100 /* Pattern had globbing characters. */	88	#define COMPAT_GLOB_MAGCHAR 0x0100 /* Pattern had globbing characters. */
89	#define GLOB_NOMAGIC 0x0200 /* GLOB_NOCHECK without magic chars (csh). */	89	#define COMPAT_GLOB_NOMAGIC 0x0200 /* GLOB_NOCHECK without magic chars (csh). */
90	#define GLOB_QUOTE 0x0400 /* Quote special chars with \. */	90	#define COMPAT_GLOB_QUOTE 0x0400 /* Quote special chars with \. */
91	#define GLOB_TILDE 0x0800 /* Expand tilde names from the passwd file. */	91	#define COMPAT_GLOB_TILDE 0x0800 /* Expand tilde names from the passwd file. */
92	#define GLOB_LIMIT 0x2000 /* Limit pattern match output to ARG_MAX */	92	#define COMPAT_GLOB_LIMIT 0x2000 /* Limit pattern match output to ARG_MAX */
93	#define GLOB_KEEPSTAT 0x4000 /* Retain stat data for paths in gl_statv. */	93	#define COMPAT_GLOB_KEEPSTAT 0x4000 /* Retain stat data for paths in gl_statv. */
94	#define GLOB_ABEND GLOB_ABORTED /* backward compatibility */	94	#define COMPAT_GLOB_ABEND COMPAT_GLOB_ABORTED /* backward compatibility */
95		95
96	int glob(const char , int, int ()(const char , int), glob_t );	96	int compat_glob(const char , int, int ()(const char , int), compat_glob_t );
97	void globfree(glob_t *);	97	void compat_globfree(compat_glob_t *);
98		98
99	#endif /* !_GLOB_H_ */	99	#endif /* !_COMPAT_GLOB_H_ */
100		100
101	#endif /* !defined(HAVE_GLOB_H) \|\| !defined(GLOB_HAS_ALTDIRFUNC) \|\|	101	#endif /* !defined(HAVE_GLOB_H) \|\| !defined(GLOB_HAS_ALTDIRFUNC) \|\|
102	!defined(GLOB_HAS_GL_MATCHC) \|\| !defined(GLOH_HAS_GL_STATV) */	102	!defined(GLOB_HAS_GL_MATCHC) \|\| !defined(GLOH_HAS_GL_STATV) */