/*

 * filefuncs.c - Builtin functions that provide initial minimal iterface

 *		 to the file system.

 *

 * Arnold Robbins, update for 3.1, Mon Nov 23 12:53:39 EST 1998

 * Arnold Robbins and John Haque, update for 3.1.4, applied Mon Jun 14 13:55:30 IDT 2004

 * Arnold Robbins and Andrew Schorr, revised for new extension API, May 2012.

 * Arnold Robbins, add fts(), August 2012

 * Arnold Robbins, add statvfs(), November 2015

 */

/*

 * Copyright (C) 2001, 2004, 2005, 2010-2017

 * the Free Software Foundation, Inc.

 *

 * This file is part of GAWK, the GNU implementation of the

 * AWK Programming Language.

 *

 * GAWK is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * GAWK is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#define _BSD_SOURCE

#ifdef __VMS

#if (__CRTL_VER >= 70200000) && !defined (__VAX)

#define _LARGEFILE 1

#endif

#ifndef __VAX

#ifdef __CRTL_VER

#if __CRTL_VER >= 80200000

#define _USE_STD_STAT 1

#endif

#endif

#endif

#define _POSIX_C_SOURCE 1

#define _XOPEN_SOURCE 1

#include <stat.h>

#ifndef S_ISVTX

#define S_ISVTX (0)

#endif

#ifndef major

#define major(s) (s)

#endif

#ifndef minor

#define minor(s) (0)

#endif

#include <unixlib.h>

#endif

#include <stdio.h>

#include <assert.h>

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif /* HAVE_SYS_PARAM_H */

#if HAVE_SYS_SYSMACROS_H

#include <sys/sysmacros.h>

#elif HAVE_SYS_MKDEV_H

#include <sys/mkdev.h>

#endif /* HAVE_SYS_MKDEV_H */

#include <sys/types.h>

#include <sys/stat.h>

#if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)

#include <sys/statvfs.h>

#endif

#include "gawkapi.h"

#include "gettext.h"

#define _(msgid)  gettext(msgid)

#define N_(msgid) msgid

#include "gawkfts.h"

#include "stack.h"

#ifndef S_IFLNK

#define lstat stat

#define S_ISLNK(s) 0

#define readlink(f,b,bs) (-1)

#endif

#ifdef __MINGW32__

#define S_IRGRP S_IRUSR

#define S_IWGRP S_IWUSR

#define S_IXGRP S_IXUSR

#define S_IROTH S_IRUSR

#define S_IWOTH S_IWUSR

#define S_IXOTH S_IXUSR

#define S_ISUID 0

#define S_ISGID 0

#define S_ISVTX 0

#define major(s) (s)

#define minor(s) (0)

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

/* get_inode --- get the inode of a file */

static long long

get_inode(const char *fname)

{

	HANDLE fh;

	BY_HANDLE_FILE_INFORMATION info;

	fh = CreateFile(fname, 0, 0, NULL, OPEN_EXISTING,

			FILE_FLAG_BACKUP_SEMANTICS, NULL);

	if (fh == INVALID_HANDLE_VALUE)

		return 0;

	if (GetFileInformationByHandle(fh, &info)) {

		long long inode = info.nFileIndexHigh;

		inode <<= 32;

		inode += info.nFileIndexLow;

		return inode;

	}

	return 0;

}

#endif

static const gawk_api_t *api;	/* for convenience macros to work */

static awk_ext_id_t ext_id;

static awk_bool_t init_filefuncs(void);

static awk_bool_t (*init_func)(void) = init_filefuncs;

static const char *ext_version = "filefuncs extension: version 1.0";

int plugin_is_GPL_compatible;

/*  do_chdir --- provide dynamically loaded chdir() function for gawk */

static awk_value_t *

do_chdir(int nargs, awk_value_t *result, struct awk_ext_func *unused)

{

	awk_value_t newdir;

	int ret = -1;

	assert(result != NULL);

	if (get_argument(0, AWK_STRING, & newdir)) {

		ret = chdir(newdir.str_value.str);

		if (ret < 0)

			update_ERRNO_int(errno);

	}

	return make_number(ret, result);

}

/* format_mode --- turn a stat mode field into something readable */

static char *

format_mode(unsigned long fmode)

{

	static char outbuf[12];

	static struct ftype_map {

		unsigned int mask;

		int charval;

	} ftype_map[] = {

		{ S_IFREG, '-' },	/* redundant */

		{ S_IFBLK, 'b' },

		{ S_IFCHR, 'c' },

		{ S_IFDIR, 'd' },

#ifdef S_IFSOCK

		{ S_IFSOCK, 's' },

#endif

#ifdef S_IFIFO

		{ S_IFIFO, 'p' },

#endif

#ifdef S_IFLNK

		{ S_IFLNK, 'l' },

#endif

#ifdef S_IFDOOR	/* Solaris weirdness */

		{ S_IFDOOR, 'D' },

#endif /* S_IFDOOR */

	};

	static struct mode_map {

		unsigned int mask;

		int rep;

	} map[] = {

		{ S_IRUSR, 'r' }, { S_IWUSR, 'w' }, { S_IXUSR, 'x' },

		{ S_IRGRP, 'r' }, { S_IWGRP, 'w' }, { S_IXGRP, 'x' },

		{ S_IROTH, 'r' }, { S_IWOTH, 'w' }, { S_IXOTH, 'x' },

	};

	static struct setuid_map {

		unsigned int mask;

		int index;

		int small_rep;

		int big_rep;

	} setuid_map[] = {

		{ S_ISUID, 3, 's', 'S' }, /* setuid bit */

		{ S_ISGID, 6, 's', 'l' }, /* setgid without execute == locking */

		{ S_ISVTX, 9, 't', 'T' }, /* the so-called "sticky" bit */

	};

	int i, j, k;

	strcpy(outbuf, "----------");

	/* first, get the file type */

	i = 0;

	for (j = 0, k = sizeof(ftype_map)/sizeof(ftype_map[0]); j < k; j++) {

		if ((fmode & S_IFMT) == ftype_map[j].mask) {

			outbuf[i] = ftype_map[j].charval;

			break;

		}

	}

	/* now the permissions */

	for (j = 0, k = sizeof(map)/sizeof(map[0]); j < k; j++) {

		i++;

		if ((fmode & map[j].mask) != 0)

			outbuf[i] = map[j].rep;

	}

	i++;

	outbuf[i] = '\0';

	/* tweaks for the setuid / setgid / sticky bits */

	for (j = 0, k = sizeof(setuid_map)/sizeof(setuid_map[0]); j < k; j++) {

		if (fmode & setuid_map[j].mask) {

			if (outbuf[setuid_map[j].index] == 'x')

				outbuf[setuid_map[j].index] = setuid_map[j].small_rep;

			else

				outbuf[setuid_map[j].index] = setuid_map[j].big_rep;

		}

	}

	return outbuf;

}

/* read_symlink --- read a symbolic link into an allocated buffer.

   This is based on xreadlink; the basic problem is that lstat cannot be relied

   upon to return the proper size for a symbolic link.  This happens,

   for example, on GNU/Linux in the /proc filesystem, where the symbolic link

   sizes are often 0. */

#ifndef SIZE_MAX

# define SIZE_MAX ((size_t) -1)

#endif

#ifndef SSIZE_MAX

# define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))

#endif

#define MAXSIZE (SIZE_MAX < SSIZE_MAX ? SIZE_MAX : SSIZE_MAX)

static char *

read_symlink(const char *fname, size_t bufsize, ssize_t *linksize)

{

	if (bufsize)

		bufsize += 2;

	else

		bufsize = BUFSIZ * 2;

	/* Make sure that bufsize >= 2 and within range */

	if (bufsize > MAXSIZE || bufsize < 2)

		bufsize = MAXSIZE;

	while (1) {

		char *buf;

		emalloc(buf, char *, bufsize, "read_symlink");

		if ((*linksize = readlink(fname, buf, bufsize)) < 0) {

			/* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink

			   returns -1 with errno == ERANGE if the buffer is

			   too small.  */

			if (errno != ERANGE) {

				gawk_free(buf);

				return NULL;

			}

		}

		/* N.B. This test is safe because bufsize must be >= 2 */

		else if ((size_t)*linksize <= bufsize-2) {

			buf[*linksize] = '\0';

			return buf;

		}

		gawk_free(buf);

		if (bufsize <= MAXSIZE/2)

			bufsize *= 2;

		else if (bufsize < MAXSIZE)

			bufsize = MAXSIZE;

		else

			return NULL;

	}

	return NULL;

}

/* device_blocksize --- try to figure out units of st_blocks */

static int

device_blocksize()

{

	/* some of this derived from GNULIB stat-size.h */

#if defined(DEV_BSIZE)

	/* <sys/param.h>, most systems */

	return DEV_BSIZE;

#elif defined(S_BLKSIZE)

	/* <sys/stat.h>, BSD systems */

	return S_BLKSIZE;

#elif defined hpux || defined __hpux__ || defined __hpux

	return 1024;

#elif defined _AIX && defined _I386

	/* AIX PS/2 counts st_blocks in 4K units.  */

	return 4 * 1024;

#elif defined __MINGW32__

	return 1024;

#else

	return 512;

#endif

}

/* array_set --- set an array element */

static void

array_set(awk_array_t array, const char *sub, awk_value_t *value)

{

	awk_value_t index;

	set_array_element(array,

			make_const_string(sub, strlen(sub), & index),

			value);

}

/* array_set_numeric --- set an array element with a number */

static void

array_set_numeric(awk_array_t array, const char *sub, double num)

{

	awk_value_t tmp;

	array_set(array, sub, make_number(num, & tmp));

}

/* fill_stat_array --- do the work to fill an array with stat info */

static int

fill_stat_array(const char *name, awk_array_t array, struct stat *sbuf)

{

	char *pmode;	/* printable mode */

	const char *type = "unknown";

	awk_value_t tmp;

	static struct ftype_map {

		unsigned int mask;

		const char *type;

	} ftype_map[] = {

		{ S_IFREG, "file" },

		{ S_IFBLK, "blockdev" },

		{ S_IFCHR, "chardev" },

		{ S_IFDIR, "directory" },

#ifdef S_IFSOCK

		{ S_IFSOCK, "socket" },

#endif

#ifdef S_IFIFO

		{ S_IFIFO, "fifo" },

#endif

#ifdef S_IFLNK

		{ S_IFLNK, "symlink" },

#endif

#ifdef S_IFDOOR	/* Solaris weirdness */

		{ S_IFDOOR, "door" },

#endif /* S_IFDOOR */

	};

	int j, k;

	/* empty out the array */

	clear_array(array);

	/* fill in the array */

	array_set(array, "name", make_const_string(name, strlen(name), & tmp));

	array_set_numeric(array, "dev", sbuf->st_dev);

#ifdef __MINGW32__

	array_set_numeric(array, "ino", (double)get_inode (name));

#else

	array_set_numeric(array, "ino", sbuf->st_ino);

#endif

	array_set_numeric(array, "mode", sbuf->st_mode);

	array_set_numeric(array, "nlink", sbuf->st_nlink);

	array_set_numeric(array, "uid", sbuf->st_uid);

	array_set_numeric(array, "gid", sbuf->st_gid);

	array_set_numeric(array, "size", sbuf->st_size);

#ifdef __MINGW32__

	array_set_numeric(array, "blocks", (sbuf->st_size + 4095) / 4096);

#else

	array_set_numeric(array, "blocks", sbuf->st_blocks);

#endif

	array_set_numeric(array, "atime", sbuf->st_atime);

	array_set_numeric(array, "mtime", sbuf->st_mtime);

	array_set_numeric(array, "ctime", sbuf->st_ctime);

	/* for block and character devices, add rdev, major and minor numbers */

	if (S_ISBLK(sbuf->st_mode) || S_ISCHR(sbuf->st_mode)) {

		array_set_numeric(array, "rdev", sbuf->st_rdev);

		array_set_numeric(array, "major", major(sbuf->st_rdev));

		array_set_numeric(array, "minor", minor(sbuf->st_rdev));

	}

#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE

	array_set_numeric(array, "blksize", sbuf->st_blksize);

#elif defined(__MINGW32__)

	array_set_numeric(array, "blksize", 4096);

#endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */

	/* the size of a block for st_blocks */

	array_set_numeric(array, "devbsize", device_blocksize());

	pmode = format_mode(sbuf->st_mode);

	array_set(array, "pmode", make_const_string(pmode, strlen(pmode), & tmp));

	/* for symbolic links, add a linkval field */

	if (S_ISLNK(sbuf->st_mode)) {

		char *buf;

		ssize_t linksize;

		if ((buf = read_symlink(name, sbuf->st_size,

					& linksize)) != NULL)

			array_set(array, "linkval", make_malloced_string(buf, linksize, & tmp));

		else

			warning(ext_id, _("stat: unable to read symbolic link `%s'"), name);

	}

	/* add a type field */

	type = "unknown";	/* shouldn't happen */

	for (j = 0, k = sizeof(ftype_map)/sizeof(ftype_map[0]); j < k; j++) {

		if ((sbuf->st_mode & S_IFMT) == ftype_map[j].mask) {

			type = ftype_map[j].type;

			break;

		}

	}

	array_set(array, "type", make_const_string(type, strlen(type), & tmp));

	return 0;

}

/* do_stat --- provide a stat() function for gawk */

static awk_value_t *

do_stat(int nargs, awk_value_t *result, struct awk_ext_func *unused)

{

	awk_value_t file_param, array_param;

	char *name;

	awk_array_t array;

	int ret;

	struct stat sbuf;

	int (*statfunc)(const char *path, struct stat *sbuf) = lstat;	/* default */

	assert(result != NULL);

	/* file is first arg, array to hold results is second */

	if (   ! get_argument(0, AWK_STRING, & file_param)

	    || ! get_argument(1, AWK_ARRAY, & array_param)) {

		warning(ext_id, _("stat: bad parameters"));

		return make_number(-1, result);

	}

	if (nargs == 3) {

		statfunc = stat;

	}

	name = file_param.str_value.str;

	array = array_param.array_cookie;

	/* always empty out the array */

	clear_array(array);

	/* stat the file; if error, set ERRNO and return */

	ret = statfunc(name, & sbuf);

	if (ret < 0) {

		update_ERRNO_int(errno);

		return make_number(ret, result);

	}

	ret = fill_stat_array(name, array, & sbuf);

	return make_number(ret, result);

}

#if defined(HAVE_SYS_STATVFS_H) && defined(HAVE_STATVFS)

/* do_statvfs --- provide a statvfs() function for gawk */

static awk_value_t *

do_statvfs(int nargs, awk_value_t *result, struct awk_ext_func *unused)

{

	awk_value_t file_param, array_param;

	char *name;

	awk_array_t array;

	int ret;

	struct statvfs vfsbuf;

	assert(result != NULL);

	/* file is first arg, array to hold results is second */

	if (   ! get_argument(0, AWK_STRING, & file_param)

	    || ! get_argument(1, AWK_ARRAY, & array_param)) {

		warning(ext_id, _("stat: bad parameters"));

		return make_number(-1, result);

	}

	name = file_param.str_value.str;

	array = array_param.array_cookie;

	/* always empty out the array */

	clear_array(array);

	/* stat the file; if error, set ERRNO and return */

	ret = statvfs(name, & vfsbuf);

	if (ret < 0) {

		update_ERRNO_int(errno);

		return make_number(ret, result);

	}

	array_set_numeric(array, "bsize", vfsbuf.f_bsize);	/* filesystem block size */

	array_set_numeric(array, "frsize", vfsbuf.f_frsize);	/* fragment size */

	array_set_numeric(array, "blocks", vfsbuf.f_blocks);	/* size of fs in f_frsize units */

	array_set_numeric(array, "bfree", vfsbuf.f_bfree);	/* # free blocks */

	array_set_numeric(array, "bavail", vfsbuf.f_bavail);	/* # free blocks for unprivileged users */

	array_set_numeric(array, "files", vfsbuf.f_files);	/* # inodes */

	array_set_numeric(array, "ffree", vfsbuf.f_ffree);	/* # free inodes */

	array_set_numeric(array, "favail", vfsbuf.f_favail);	/* # free inodes for unprivileged users */

#ifndef _AIX

	array_set_numeric(array, "fsid", vfsbuf.f_fsid);	/* filesystem ID */

#endif

	array_set_numeric(array, "flag", vfsbuf.f_flag);	/* mount flags */

	array_set_numeric(array, "namemax", vfsbuf.f_namemax);	/* maximum filename length */

	return make_number(ret, result);

}

#endif

/* init_filefuncs --- initialization routine */

static awk_bool_t

init_filefuncs(void)

{

	int errors = 0;

	int i;

	awk_value_t value;

#ifndef __MINGW32__

	/* at least right now, only FTS needs initializing */

	static struct flagtab {

		const char *name;

		int value;

	} opentab[] = {

#define ENTRY(x)	{ #x, x }

		ENTRY(FTS_COMFOLLOW),

		ENTRY(FTS_LOGICAL),

		ENTRY(FTS_NOCHDIR),

		ENTRY(FTS_PHYSICAL),

		ENTRY(FTS_SEEDOT),

		ENTRY(FTS_XDEV),

		{ NULL, 0 }

	};

	for (i = 0; opentab[i].name != NULL; i++) {

		(void) make_number(opentab[i].value, & value);

		if (! sym_update(opentab[i].name, & value)) {

			warning(ext_id, _("fts init: could not create variable %s"),

					opentab[i].name);

			errors++;

		}

	}

#endif

	return errors == 0;

}

#ifdef __MINGW32__

/*  do_fts --- walk a hierarchy and fill in an array */

/*

 * Usage from awk:

 *	flags = or(FTS_PHYSICAL, ...)

 *	result = fts(pathlist, flags, filedata)

 */

static awk_value_t *

do_fts(int nargs, awk_value_t *result, struct awk_ext_func *unused)

{

	fatal(ext_id, _("fts is not supported on this system"));

	return NULL;	/* for the compiler */

}

#else /* __MINGW32__ */

static int fts_errors = 0;

/* fill_stat_element --- fill in stat element of array */

static void

fill_stat_element(awk_array_t element_array, const char *name, struct stat *sbuf)

{

	awk_value_t index, value;

	awk_array_t stat_array;

	stat_array = create_array();

	if (stat_array == NULL) {

		warning(ext_id, _("fill_stat_element: could not create array"));

		fts_errors++;

		return;

	}

	fill_stat_array(name, stat_array, sbuf);

	(void) make_const_string("stat", 4, & index);

	value.val_type = AWK_ARRAY;

	value.array_cookie = stat_array;

	if (! set_array_element(element_array, & index, & value)) {

		warning(ext_id, _("fill_stat_element: could not set element"));

		fts_errors++;

	}

}

/* fill_path_element --- fill in path element of array */

static void

fill_path_element(awk_array_t element_array, const char *path)

{

	awk_value_t index, value;

	(void) make_const_string("path", 4, & index);

	(void) make_const_string(path, strlen(path), & value);

	if (! set_array_element(element_array, & index, & value)) {

		warning(ext_id, _("fill_path_element: could not set element"));

		fts_errors++;

	}

}

/* fill_error_element --- fill in error element of array */

static void

fill_error_element(awk_array_t element_array, const int errcode)

{

	awk_value_t index, value;

	const char *err = strerror(errcode);

	(void) make_const_string("error", 5, & index);

	(void) make_const_string(err, strlen(err), & value);

	if (! set_array_element(element_array, & index, & value)) {

		warning(ext_id, _("fill_error_element: could not set element"));

		fts_errors++;

	}

}

/* fill_default_elements --- fill in stat and path elements */

static void

fill_default_elements(awk_array_t element_array, const FTSENT *const fentry, awk_bool_t bad_ret)

{

	/* full path */

	fill_path_element(element_array, fentry->fts_path);

	/* stat info */

	if (! bad_ret) {

		fill_stat_element(element_array,

				fentry->fts_name,

				fentry->fts_statp);

	}

	/* error info */

	if (bad_ret || fentry->fts_errno != 0) {

		fill_error_element(element_array, fentry->fts_errno);

	}

}

/* process --- process the hierarchy */

static void

process(FTS *hierarchy, awk_array_t destarray, int seedot)

{

	FTSENT *fentry;

	awk_value_t index, value;

	awk_array_t element_array, newdir_array, dot_array;

	awk_bool_t bad_ret = awk_false;

	/* path is full path,  pathlen is length thereof */

	/* name is name in directory, namelen is length thereof */

	while ((fentry = fts_read(hierarchy)) != NULL) {

		bad_ret = awk_false;

		switch (fentry->fts_info) {

		case FTS_D:

			/* directory */

			/* create array to hold entries */

			newdir_array = create_array();

			if (newdir_array == NULL) {

				warning(ext_id, _("fts-process: could not create array"));

				fts_errors++;

				break;

			}

			/* store new directory in its parent directory */

			(void) make_const_string(fentry->fts_name, fentry->fts_namelen, & index);

			value.val_type = AWK_ARRAY;

			value.array_cookie = newdir_array;

			if (! set_array_element(destarray, & index, & value)) {

				warning(ext_id, _("fts-process: could not set element"));

				fts_errors++;

				break;

			}

			newdir_array = value.array_cookie;

			/* push current directory */

			stack_push(destarray);

			/* new directory becomes current */

			destarray = newdir_array;

			break;

		case FTS_DNR:

		case FTS_DC:

		case FTS_ERR:

		case FTS_NS:

			/* error */

			bad_ret = awk_true;

			/* fall through */

		case FTS_NSOK:

		case FTS_SL:

		case FTS_SLNONE:

		case FTS_F:

		case FTS_DOT:

			/* if see dot, skip "." */

			if (seedot && strcmp(fentry->fts_name, ".") == 0)

				break;

			/*

			 * File case.

			 * destarray is the directory we're reading.

			 * step 1: create new empty array

			 */

			element_array = create_array();

			if (element_array == NULL) {

				warning(ext_id, _("fts-process: could not create array"));

				fts_errors++;

				break;

			}

			/* step 2: add element array to parent array */

			(void) make_const_string(fentry->fts_name, fentry->fts_namelen, & index);

			value.val_type = AWK_ARRAY;

			value.array_cookie = element_array;

			if (! set_array_element(destarray, & index, & value)) {

				warning(ext_id, _("fts-process: could not set element"));

				fts_errors++;

				break;

			}

			/* step 3: fill in path, stat, error elements */

			fill_default_elements(element_array, fentry, bad_ret);

			break;

		case FTS_DP:

			/* create "." subarray */

			dot_array = create_array();

			/* add it to parent */

			(void) make_const_string(".", 1, & index);

			value.val_type = AWK_ARRAY;

			value.array_cookie = dot_array;

			if (! set_array_element(destarray, & index, & value)) {

				warning(ext_id, _("fts-process: could not set element"));

				fts_errors++;

				break;

			}

			/* fill it in with path, stat, error elements */

			fill_default_elements(dot_array, fentry, bad_ret);

			/* now pop the parent directory off the stack */

			if (! stack_empty()) {

				/* pop stack */

				destarray = stack_pop();

			}

			break;

		case FTS_DEFAULT:

			/* nothing to do */

			break;

		}

	}

}

/*  do_fts --- walk a hierarchy and fill in an array */

/*

 * Usage from awk:

 *	flags = or(FTS_PHYSICAL, ...)

 *	result = fts(pathlist, flags, filedata)

 */

static awk_value_t *

do_fts(int nargs, awk_value_t *result, struct awk_ext_func *unused)

{

	awk_value_t pathlist, flagval, dest;

	awk_flat_array_t *path_array = NULL;

	char **pathvector = NULL;

	FTS *hierarchy;

	int flags;

	size_t i, count;

	int ret = -1;

	static const int mask = (

		  FTS_COMFOLLOW | FTS_LOGICAL | FTS_NOCHDIR | FTS_PHYSICAL

		| FTS_SEEDOT | FTS_XDEV);

	assert(result != NULL);

	fts_errors = 0;		/* ensure a fresh start */

	if (nargs > 3)

		lintwarn(ext_id, _("fts: called with incorrect number of arguments, expecting 3"));

	if (! get_argument(0, AWK_ARRAY, & pathlist)) {

		warning(ext_id, _("fts: bad first parameter"));

		update_ERRNO_int(EINVAL);

		goto out;

	}

	if (! get_argument(1, AWK_NUMBER, & flagval)) {

		warning(ext_id, _("fts: bad second parameter"));

		update_ERRNO_int(EINVAL);

		goto out;

	}

	if (! get_argument(2, AWK_ARRAY, & dest)) {

		warning(ext_id, _("fts: bad third parameter"));

		update_ERRNO_int(EINVAL);

		goto out;

	}

	/* flatten pathlist */

	if (! flatten_array(pathlist.array_cookie, & path_array)) {

		warning(ext_id, _("fts: could not flatten array\n"));

		goto out;

	}

	/* check the flags first, before the array flattening */

	/* get flags */

	flags = flagval.num_value;

	/* enforce physical or logical but not both, and not no_stat */

	if ((flags & (FTS_PHYSICAL|FTS_LOGICAL)) == 0

	    || (flags & (FTS_PHYSICAL|FTS_LOGICAL)) == (FTS_PHYSICAL|FTS_LOGICAL)) {

		update_ERRNO_int(EINVAL);

		goto out;

	}

	if ((flags & FTS_NOSTAT) != 0) {

		flags &= ~FTS_NOSTAT;

		if (do_lint)

			lintwarn(ext_id, _("fts: ignoring sneaky FTS_NOSTAT flag. nyah, nyah, nyah."));

	}

	flags &= mask;	/* turn off anything else */

	/* make pathvector */

	count = path_array->count + 1;