/*	$NetBSD: function.c,v 1.62 2007/02/06 13:25:01 elad Exp $	*/

 * Copyright (c) 1990, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Cimarron D. Taylor of the University of California, Berkeley.

 *

 * 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.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.

 */

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#include <sys/cdefs.h>

#include <sys/select.h>

#ifndef lint

#if 0

static char sccsid[] = "from: @(#)function.c	8.10 (Berkeley) 5/4/95";

#else

__RCSID("$NetBSD: function.c,v 1.62 2007/02/06 13:25:01 elad Exp $");

#endif

#endif /* not lint */

#include <sys/param.h>

#include <sys/stat.h>

#include <sys/wait.h>

#ifndef __SYMBIAN32__

#include <sys/mount.h>

#endif

#include <dirent.h>

#include <err.h>

#include <errno.h>

#include "fnmatch.h"

#include "fts.h"

#include <grp.h>

#include <inttypes.h>

#include <limits.h>

#include <pwd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "tzfile.h"

#include <unistd.h>

#include "util.h"

#include "find.h"

//setmode.c definition added. strtoul will convert a string to an unsigned long integer and 

//will be returned by the setmode function.

#ifndef __SYMBIAN32__

void *

setmode(const char *str)

{

	mode_t *mp = malloc(sizeof(mode_t));

	*mp = strtoul(str, NULL, 8);

	return mp;

}

//getmode.c definition 

mode_t

getmode(const void *mp, mode_t mode)

{

	mode_t m;

	m = *((const mode_t *)mp);

	mode &= ~ALLPERMS;	/* input mode less RWX permissions */

	m &= ALLPERMS;		/* new RWX permissions */

	return m | mode;

}

#endif

#define	TEST(a, b, f) {							\

	if (!memcmp(a, b, sizeof(b))) {					\

		if (clear) {						\

			if (clrp)					\

				*clrp |= (f);				\

		} else if (setp)					\

			*setp |= (f);					\

		break;							\

	}								\

}

/*

 * string_to_flags --

 *	Take string of arguments and return stat flags.  Return 0 on

 *	success, 1 on failure.  On failure, stringp is set to point

 *	to the offending token.

 */

int string_to_flags(char **stringp, u_int *setp,u_int *clrp)

{

	int clear;

	char *string, *p;

	if (setp)

		*setp = 0;

	if (clrp)

		*clrp = 0;

	string = *stringp;

	while ((p = strsep(&string, "\t ,")) != NULL) {

		clear = 0;

		*stringp = p;

		if (*p == '\0')

			continue;

		if (p[0] == 'n' && p[1] == 'o') {

			clear = 1;

			p += 2;

		}

		switch (p[0]) {

		case 'a':

			TEST(p, "arch", SF_ARCHIVED);

			TEST(p, "archived", SF_ARCHIVED);

			return (1);

		case 'd':

			clear = !clear;

			TEST(p, "dump", UF_NODUMP);

			return (1);

		case 'o':

			TEST(p, "opaque", UF_OPAQUE);

			return (1);

		case 's':

			TEST(p, "sappnd", SF_APPEND);

			TEST(p, "sappend", SF_APPEND);

			TEST(p, "schg", SF_IMMUTABLE);

			TEST(p, "schange", SF_IMMUTABLE);

			TEST(p, "simmutable", SF_IMMUTABLE);

			return (1);

		case 'u':

			TEST(p, "uappnd", UF_APPEND);

			TEST(p, "uappend", UF_APPEND);

			TEST(p, "uchg", UF_IMMUTABLE);

			TEST(p, "uchange", UF_IMMUTABLE);

			TEST(p, "uimmutable", UF_IMMUTABLE);

			/* FALLTHROUGH */

		default:

			return (1);

		}

	}

	return 0;

}

//Emalloc definition..

void *emalloc(unsigned size)

{

    void *p = malloc(size);

    if (p == NULL) {

        fprintf(stderr, "out of memory!\n");

        exit(1);

    }

    return p;

}

//-----------------------------------------------------

#define	COMPARE(a, b) {							\

	switch (plan->flags) {						\

	case F_EQUAL:							\

		return (a == b);					\

	case F_LESSTHAN:						\

		return (a < b);						\

	case F_GREATER:							\

		return (a > b);						\

	default:							\

		abort();						\

	}								\

}

static	int64_t	find_parsenum(PLAN *, const char *, const char *, char *);

static	void	run_f_exec(PLAN *);

	int	f_always_true(PLAN *, FTSENT *);

	int	f_amin(PLAN *, FTSENT *);

	int	f_anewer(PLAN *, FTSENT *);

	int	f_atime(PLAN *, FTSENT *);

	int	f_cmin(PLAN *, FTSENT *);

	int	f_cnewer(PLAN *, FTSENT *);

	int	f_ctime(PLAN *, FTSENT *);

	int	f_delete(PLAN *, FTSENT *);

	int	f_empty(PLAN *, FTSENT *);

	int	f_exec(PLAN *, FTSENT *);

	int	f_execdir(PLAN *, FTSENT *);

	int	f_false(PLAN *, FTSENT *);

	int	f_flags(PLAN *, FTSENT *);

	int	f_fprint(PLAN *, FTSENT *);

	int	f_fstype(PLAN *, FTSENT *);

	int	f_group(PLAN *, FTSENT *);

	int	f_iname(PLAN *, FTSENT *);

	int	f_inum(PLAN *, FTSENT *);

	int	f_links(PLAN *, FTSENT *);

	int	f_ls(PLAN *, FTSENT *);

	int	f_mindepth(PLAN *, FTSENT *);

	int	f_maxdepth(PLAN *, FTSENT *);

	int	f_mmin(PLAN *, FTSENT *);

	int	f_mtime(PLAN *, FTSENT *);

	int	f_name(PLAN *, FTSENT *);

	int	f_newer(PLAN *, FTSENT *);

	int	f_nogroup(PLAN *, FTSENT *);

	int	f_nouser(PLAN *, FTSENT *);

	int	f_path(PLAN *, FTSENT *);

	int	f_perm(PLAN *, FTSENT *);

	int	f_print(PLAN *, FTSENT *);

	int	f_print0(PLAN *, FTSENT *);

	int	f_printx(PLAN *, FTSENT *);

	int	f_prune(PLAN *, FTSENT *);

	int	f_regex(PLAN *, FTSENT *);

	int	f_size(PLAN *, FTSENT *);

	int	f_type(PLAN *, FTSENT *);

	int	f_user(PLAN *, FTSENT *);

	int	f_not(PLAN *, FTSENT *);

	int	f_or(PLAN *, FTSENT *);

#ifndef __SYMBIAN32__

static	PLAN   *c_regex_common(char ***, int, enum ntype, int);

#endif

static	PLAN   *palloc(enum ntype, int (*)(PLAN *, FTSENT *));

extern int dotfd;

extern FTS *tree;

extern time_t now;

/*

 * find_parsenum --

 *	Parse a string of the form [+-]# and return the value.

 */

static int64_t

find_parsenum(PLAN *plan, const char *option, const char *vp, char *endch)

{

	int64_t value;

	const char *str;

	char *endchar; /* Pointer to character ending conversion. */

	/* Determine comparison from leading + or -. */

	str = vp;

	switch (*str) {

	case '+':

		++str;

		plan->flags = F_GREATER;

		break;

	case '-':

		++str;

		plan->flags = F_LESSTHAN;

		break;

	default:

		plan->flags = F_EQUAL;

		break;

	}

	/*

	 * Convert the string with strtol().  Note, if strtol() returns zero

	 * and endchar points to the beginning of the string we know we have

	 * a syntax error.

	 */

	value = strtoq(str, &endchar, 10);

	if (value == 0 && endchar == str)

		printf("%s: %s: illegal numeric value", option, vp);

	if (endchar[0] && (endch == NULL || endchar[0] != *endch))

	printf("%s: %s: illegal trailing character", option, vp);

	if (endch)

		*endch = endchar[0];

	return (value);

}

/*

 * The value of n for the inode times (atime, ctime, and mtime) is a range,

 * i.e. n matches from (n - 1) to n 24 hour periods.  This interacts with

 * -n, such that "-mtime -1" would be less than 0 days, which isn't what the

 * user wanted.  Correct so that -1 is "less than 1".

 */

#define	TIME_CORRECT(p, ttype)						\

	if ((p)->type == ttype && (p)->flags == F_LESSTHAN)		\

		++((p)->t_data);

/*

 * -amin n functions --

 *

 *	True if the difference between the file access time and the

 *	current time is n 1 minute periods.

 */

int

f_amin(PLAN *plan, FTSENT *entry)

{

	COMPARE((now - entry->fts_statp->st_atime +

	    SECSPERMIN - 1) / SECSPERMIN, plan->t_data);

	    return 0;

}

PLAN *

c_amin(char ***argvp, int isok)

{

	char *arg = **argvp;

	PLAN *new;

	(*argvp)++;

	ftsoptions &= ~FTS_NOSTAT;

	new = palloc(N_AMIN, f_amin);

	new->t_data = find_parsenum(new, "-amin", arg, NULL);

	TIME_CORRECT(new, N_AMIN);

	return (new);

}

/*

 * -anewer file functions --

 *

 *	True if the current file has been accessed more recently

 *	than the access time of the file named by the pathname

 *	file.

 */

int f_anewer(PLAN *plan, FTSENT *entry)

{

	return (entry->fts_statp->st_atime > plan->t_data);

}

PLAN *

c_anewer(char ***argvp, int isok)

{

	char *filename = **argvp;

	PLAN *new;

	struct stat sb;

	(*argvp)++;

	ftsoptions &= ~FTS_NOSTAT;

	if (stat(filename, &sb))

		printf("%s", filename);

	new = palloc(N_ANEWER, f_anewer);

	new->t_data = sb.st_atime;

	return (new);

}

/*

 * -atime n functions --

 *

 *	True if the difference between the file access time and the

 *	current time is n 24 hour periods.

 */

int

f_atime(PLAN *plan, FTSENT *entry)

{

	COMPARE((now - entry->fts_statp->st_atime +

	    SECSPERDAY - 1) / SECSPERDAY, plan->t_data);

	    return 0;

}

PLAN *

c_atime(char ***argvp, int isok)

{

	char *arg = **argvp;

	PLAN *new;

	(*argvp)++;

	ftsoptions &= ~FTS_NOSTAT;

	new = palloc(N_ATIME, f_atime);

	new->t_data = find_parsenum(new, "-atime", arg, NULL);

	TIME_CORRECT(new, N_ATIME);

	return (new);

}

/*

 * -cmin n functions --

 *

 *	True if the difference between the last change of file

 *	status information and the current time is n 24 hour periods.

 */

int

f_cmin(PLAN *plan, FTSENT *entry)

{

	COMPARE((now - entry->fts_statp->st_ctime +

	    SECSPERMIN - 1) / SECSPERMIN, plan->t_data);

	return 0;

}

PLAN *

c_cmin(char ***argvp, int isok)

{

	char *arg = **argvp;

	PLAN *new;

	(*argvp)++;

	ftsoptions &= ~FTS_NOSTAT;

	new = palloc(N_CMIN, f_cmin);

	new->t_data = find_parsenum(new, "-cmin", arg, NULL);

	TIME_CORRECT(new, N_CMIN);

	return (new);

}

/*

 * -cnewer file functions --

 *

 *	True if the current file has been changed more recently

 *	than the changed time of the file named by the pathname

 *	file.

 */

int

f_cnewer(PLAN *plan, FTSENT *entry)

{

	return (entry->fts_statp->st_ctime > plan->t_data);

}

PLAN *

c_cnewer(char ***argvp, int isok)

{

	char *filename = **argvp;

	PLAN *new;

	struct stat sb;

	(*argvp)++;

	ftsoptions &= ~FTS_NOSTAT;

	if (stat(filename, &sb))

		printf("%s", filename);

	new = palloc(N_CNEWER, f_cnewer);

	new->t_data = sb.st_ctime;

	return (new);

}

/*

 * -ctime n functions --

 *

 *	True if the difference between the last change of file

 *	status information and the current time is n 24 hour periods.

 */

int

f_ctime(PLAN *plan, FTSENT *entry)

{

	COMPARE((now - entry->fts_statp->st_ctime +

	    SECSPERDAY - 1) / SECSPERDAY, plan->t_data);

	    return 0;

}

PLAN *

c_ctime(char ***argvp, int isok)

{

	char *arg = **argvp;

	PLAN *new;

	(*argvp)++;

	ftsoptions &= ~FTS_NOSTAT;

	new = palloc(N_CTIME, f_ctime);

	new->t_data = find_parsenum(new, "-ctime", arg, NULL);

	TIME_CORRECT(new, N_CTIME);

	return (new);

}

/*

 * -delete functions --

 *

 *	True always.  Makes its best shot and continues on regardless.

 */

int

f_delete(PLAN *plan __unused, FTSENT *entry)

{

	/* ignore these from fts */

	if (strcmp(entry->fts_accpath, ".") == 0 ||