/*

  *  Copyright (C) 2002 - 2004 Tomasz Kojm <tkojm@clamav.net>

  *
  *  This program 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 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  *  Sat May 18 15:23:21 CEST 2002: included cpu autodetection from Magnus Ekdahl
  *  Wed Mar  5 03:45:31 CET 2003: included --move code from Damien Curtain
  */
 

 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <grp.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <signal.h>
 #include <clamav.h>
 #include <errno.h>
 

 #ifdef HAVE_REGEX_H
 #include <regex.h>
 #endif
 

 #include "defaults.h"
 #include "others.h"
 #include "options.h"
 #include "manager.h"
 #include "treewalk.h"
 #include "shared.h"

 #include "str.h"
 #include "strrcpy.h"

 #include "memory.h"
 #include "output.h"

 #include "cfgparser.h"

 #include "../libclamav/others.h"

 
 #ifdef C_LINUX
 dev_t procdev;
 #endif
 

 int scanmanager(const struct optstruct *opt)
 {
 	mode_t fmode;
 	int ret = 0, compression = 0, fmodeint;
 	struct cl_node *trie = NULL;
 	struct cl_limits *limits = NULL;
 	struct passwd *user = NULL;
 	struct stat sb;

 	char *fullpath = NULL, cwd[1024];

 	struct cfgstruct *copt, *cpt;
 	struct cl_cvd *d1, *d2;
 	const char *dbdir;

 
 /* njh@bandsman.co.uk: BeOS */
 #if !defined(C_CYGWIN) && !defined(C_BEOS)

     if(!geteuid()) {

 	if((user = getpwnam(UNPUSER)) == NULL) {
 	    mprintf("@Can't get information about user "UNPUSER".\n");
 	    exit(60); /* this is critical problem, so we just exit here */
 	}
     }
 #endif
 

     if(optl(opt, "unzip") || optl(opt, "unrar") || optl(opt, "arj") ||
        optl(opt, "unzoo") || optl(opt, "jar") || optl(opt, "lha") ||
        optl(opt, "tar") || optl(opt, "tgz") || optl(opt, "deb"))

 	    compression = 1;
 
     /* now initialize the database */
 
     if(optc(opt, 'd')) {
 	stat(getargc(opt, 'd'), &sb);
 	switch(sb.st_mode & S_IFMT) {
 	    case S_IFREG:
 		if((ret = cl_loaddb(getargc(opt, 'd'), &trie, &claminfo.signs))) {

 		    mprintf("@%s\n", cl_strerror(ret));

 		    return 50;
 		}
 		break;
             case S_IFDIR:
 		if((ret = cl_loaddbdir(getargc(opt, 'd'), &trie, &claminfo.signs))) {

 		    mprintf("@%s\n", cl_strerror(ret));

 		    return 50;
 		}
 		break;
             default:
 		mprintf("@%s: Not supported database file type\n", getargc(opt, 'd'));
 		return 50;
 	}
 
     } else {

 	/* try to find fresh directory */
 	dbdir = cl_retdbdir();

 	if((copt = parsecfg(CONFDIR"/clamav.conf", 0))) {

 	    if((cpt = cfgopt(copt, "DatabaseDirectory")) || (cpt = cfgopt(copt, "DataDirectory"))) {
 		if(strcmp(cl_retdbdir(), cpt->strarg)) {
 			char *daily = (char *) mmalloc(strlen(cpt->strarg) + strlen(cl_retdbdir()) + 15);
 		    sprintf(daily, "%s/daily.cvd", cpt->strarg);
 		    if((d1 = cl_cvdhead(daily))) {
 			sprintf(daily, "%s/daily.cvd", cl_retdbdir());
 			if((d2 = cl_cvdhead(daily))) {
 			    free(daily);
 			    if(d1->version > d2->version)
 				dbdir = cpt->strarg;
 			    else
 				dbdir = cl_retdbdir();
 			    cl_cvdfree(d2);
 			} else {
 			    free(daily);
 			    dbdir = cpt->strarg;
 			}
 			cl_cvdfree(d1);
 		    } else {
 			free(daily);
 			dbdir = cl_retdbdir();
 		    }
 		}
 	    }
 	}
 
 	if((ret = cl_loaddbdir(dbdir, &trie, &claminfo.signs))) {

 	    mprintf("@%s\n", cl_strerror(ret));

 	    return 50;
 	}

 
 	if(copt)
 	    freecfg(copt);

     }
 
 
     if(!trie) {
 	mprintf("@Can't initialize the virus database.\n");
 	return 50;
     }
 

     if((ret = cl_build(trie)) != 0) {

 	mprintf("@Database initialization error: %s\n", cl_strerror(ret));;
 	return 50;
     }

 
     /* set (default) limits */
 
     limits = (struct cl_limits *) calloc(1, sizeof(struct cl_limits));
 
     if(optl(opt, "max-space")) {
 	char *cpy, *ptr;
 	ptr = getargl(opt, "max-space");
 	if(tolower(ptr[strlen(ptr) - 1]) == 'm') {
 	    cpy = mcalloc(strlen(ptr), sizeof(char));

 	    strncpy(cpy, ptr, strlen(ptr) - 1);

 	    limits->maxfilesize = atoi(cpy) * 1024 * 1024;
 	    free(cpy);
 	} else
 	    limits->maxfilesize = atoi(ptr) * 1024;
     } else
 	limits->maxfilesize = 10485760;
 
     if(optl(opt, "max-files"))
 	limits->maxfiles = atoi(getargl(opt, "max-files"));
     else
         limits->maxfiles = 500;
 
     if(optl(opt, "max-recursion"))
         limits->maxreclevel = atoi(getargl(opt, "max-recursion"));
     else
         limits->maxreclevel = 5;
 

     if(optl(opt, "max-ratio"))
         limits->maxratio = atoi(getargl(opt, "max-ratio"));
     else
         limits->maxratio = 200;

 
 #ifdef C_LINUX
     if(stat("/proc", &sb) == -1)
 	procdev = 0;
     else
 	procdev = sb.st_dev;
 #endif
 
     /* check filetype */

     if(opt->filename == NULL || strlen(opt->filename) == 0) {
 
 	/* we need full path for some reasons (eg. archive handling) */

 	if(!getcwd(cwd, sizeof(cwd))) {

 	    mprintf("@Can't get absolute pathname of current working directory.\n");
 	    ret = 57;
 	} else
 	    ret = scandirs(cwd, trie, user, opt, limits);
 
     } else if(!strcmp(opt->filename, "-")) { /* read data from stdin */

 	ret = checkstdin(trie, limits);

 
     } else {

 	int x;
 	char *thefilename;
 	for (x=0; (thefilename = cli_strtok(opt->filename, x, "\t")) != NULL; x++) {
 	    if((fmodeint = fileinfo(thefilename, 2)) == -1) {
 		mprintf("@Can't access file %s\n", thefilename);
 		perror(thefilename);
 		ret = 56;
 	    } else {
 		fmode = (mode_t) fmodeint;
 
 		if(compression && (thefilename[0] != '/')) {
 		    /* we need to complete the path */

 		    if(!getcwd(cwd, sizeof(cwd))) {

 			mprintf("@Can't get absolute pathname of current working directory.\n");
 			return 57;
 		    } else {
 			fullpath = mcalloc(512, sizeof(char));

 #ifdef NO_SNPRINTF

 			sprintf(fullpath, "%s/%s", cwd, thefilename);

 #else

 			snprintf(fullpath, 512, "%s/%s", cwd, thefilename);

 #endif

 			mprintf("*Full path: %s\n", fullpath);
 		    }
 		} else
 		    fullpath = (char *) thefilename;
 
 		switch(fmode & S_IFMT) {
 		    case S_IFREG:
 			ret = scanfile(fullpath, trie, user, opt, limits);
 			break;
 
 		    case S_IFDIR:
 			ret = scandirs(fullpath, trie, user, opt, limits);
 			break;
 
 		    default:
 			mprintf("@Not supported file type (%s)\n", thefilename);
 			ret = 52;
 		}

 		if(compression && thefilename[0] != '/') {
 		    free(fullpath);
 		    fullpath = NULL;
 		}
 	    }
 	    free(thefilename);

 	}
     }
 
     /* free the trie */

     cl_free(trie);

 
     free(limits);
 
     /* overwrite return code */
     if(claminfo.ifiles)
 	ret = 1;
     else if(ret < 50) /* hopefully no error detected */ 
 	ret = 0; /* just make sure it's 0 */
 
     return ret;
 }
 

 int match_regex(const char *filename, const char *pattern)
 {
 #ifdef HAVE_REGEX_H
 	regex_t reg;
 	int match, flags;
 #ifndef C_CYGWIN
 	flags = 0;
 #else
 	flags = REG_ICASE; /* case insensitive on Windows */
 #endif	
 	if(regcomp(&reg, pattern, flags) != 0) {
 	    mprintf("!%s: Could not parse regular expression %s.\n", filename, pattern);
 	    logg("!%s: Could not parse regular expression %s.\n", filename, pattern);
 		return 2;
 	}
 	match = (regexec(&reg, filename, 0, NULL, 0) == REG_NOMATCH) ? 0 : 1;
 	regfree(&reg);
 	return match;
 #else /* HAVE_REGEX_H */
 	return strstr(filename, pattern) ? 1 : 0;
 #endif
 }
 

 int scanfile(const char *filename, struct cl_node *root, const struct passwd *user, const struct optstruct *opt, const struct cl_limits *limits)
 {
 	int ret, options = 0, included;
 	struct optnode *optnode;
 	char *argument;
 #ifdef C_LINUX
 	struct stat sb;
 
     /* argh, don't scan /proc files */
     if(procdev)
 	if(stat(filename, &sb) != -1)
 	    if(sb.st_dev == procdev) {

 		if(!printinfected)
 		    mprintf("%s: Excluded (/proc).\n", filename);

 		return 0;
 	    }

 #endif    
     

     if(optl(opt, "exclude")) {
 	argument = getfirstargl(opt, "exclude", &optnode);
 	while (argument) {

 	    if(match_regex(filename, argument) == 1) {

 		if(!printinfected)
 		    mprintf("%s: Excluded.\n", filename);
 		return 0;
 	    }
 	    argument = getnextargl(&optnode, "exclude");
 	}
     }

      
    if(optl(opt, "include")) {

 	included = 0;
 	argument = getfirstargl(opt, "include",&optnode);
 	while (argument && !included) {

 	    if(match_regex(filename, argument) == 1)

 		included = 1;
 	    argument = getnextargl(&optnode, "include");
 	}
 
 	if (!included) {
 	    if(!printinfected)
 		mprintf("%s: Excluded.\n", filename);
 	    return 0;
 	}
 	
     }
 
     if(fileinfo(filename, 1) == 0) {
 	if(!printinfected)
 	    mprintf("%s: Empty file.\n", filename);
 	return 0;
     }
 

     if(optl(opt, "disable-archive") || optl(opt, "no-archive"))

 	options &= ~CL_ARCHIVE;
     else
 	options |= CL_ARCHIVE;
 

     if(optl(opt, "detect-broken"))
 	options |= CL_BROKEN;
 

     if(optl(opt, "block-encrypted"))

 	options |= CL_ENCRYPTED;
 

     if(optl(opt, "no-pe"))
 	options &= ~CL_PE;
     else
 	options |= CL_PE;
 

     if(optl(opt, "no-ole2"))
 	options &= ~CL_OLE2;
     else
 	options |= CL_OLE2;
 

     if(optl(opt, "no-html"))
 	options &= ~CL_HTML;
     else
 	options |= CL_HTML;
 

     if(optl(opt, "no-mail")) {
 	options &= ~CL_MAIL;
     } else {

 	options |= CL_MAIL;
 

 	if(optl(opt, "mail-follow-urls"))
 	    options |= CL_MAILURL;
     }
 

     /* 
      * check the extension  - this is a special case, normally we don't need to
      * do this (libclamav detects archive by its magic string), but here we
      * want to know the exit code from internal unpacker and try to use
      * external (if provided) when internal cannot extract data.
      */
 

     if((cli_strbcasestr(filename, ".zip") || cli_strbcasestr(filename, ".rar")) && (options & CL_ARCHIVE)) {

 	/* try to use internal archivers */

 	if((ret = checkfile(filename, root, limits, options)) == CL_VIRUS) {

 	    if(optl(opt, "remove")) {
 		if(unlink(filename)) {
 		    mprintf("%s: Can't remove.\n", filename);
 		    logg("%s: Can't remove.\n", filename);
 		    claminfo.notremoved++;
 		} else {
 		    mprintf("%s: Removed.\n", filename);
 		    logg("%s: Removed.\n", filename);
 		}
 	    } else if (optl(opt, "move"))
 		move_infected(filename, opt);
 
 	    return 1;
 
 	} else if(ret == CL_CLEAN)
 	    return 0;
 	/* in other case try to continue with external archivers */
 	options &= ~CL_ARCHIVE; /* and disable decompression for the below checkfile() */

 	claminfo.files--; /* don't count it */

     }
 

     if((cli_strbcasestr(filename, ".zip") && optl(opt, "unzip"))
     || (cli_strbcasestr(filename, ".rar") && optl(opt, "unrar"))
     || (cli_strbcasestr(filename, ".arj") && optl(opt, "arj"))
     || (cli_strbcasestr(filename, ".zoo") && optl(opt, "unzoo"))
     || (cli_strbcasestr(filename, ".jar") && optl(opt, "jar"))
     || (cli_strbcasestr(filename, ".lzh") && optl(opt, "lha"))
     || (cli_strbcasestr(filename, ".tar") && optl(opt, "tar"))
     || (cli_strbcasestr(filename, ".deb") && optl(opt, "deb"))
     || ((cli_strbcasestr(filename, ".tar.gz") || cli_strbcasestr(filename, ".tgz")) 

 	 && (optl(opt, "tgz") || optl(opt, "deb"))) ) {
 
 	/* check permissions */

 	switch(checkaccess(filename, UNPUSER, R_OK)) {

 	    case -1:
 		mprintf("@Can't get information about user "UNPUSER".\n");

 		exit(60); /* this is a critical problem so we just exit here */

 	    case -2:

 		mprintf("@Can't fork.\n");
 		exit(61);

 	    case 0: /* read access denied */

 		if(geteuid()) {

 		    if(!printinfected)
 			mprintf("%s: Access denied to archive.\n", filename);
 		} else {
 
 		    if(limits && limits->maxfilesize)
 			if(fileinfo(filename, 1) / 1024 > limits->maxfilesize) {
 			    if(!printinfected)
 				mprintf("%s: Archive too big.\n", filename);
 			    return 0;
 			}
 
 		    return(scandenied(filename, root, user, opt, limits));
 		}
 		return 0;
 	    case 1:
 		return(scancompressed(filename, root, user, opt, limits));
 	}
     }
 

     if(geteuid())

 	if(checkaccess(filename, NULL, R_OK) != 1) {
 	    if(!printinfected)
 		mprintf("%s: Access denied.\n", filename);
 	    return 0;

 	}
 
     if((ret = checkfile(filename, root, limits, options)) == CL_VIRUS) {
 	if(optl(opt, "remove")) {
 	    if(unlink(filename)) {
 		mprintf("%s: Can't remove.\n", filename);
 		logg("%s: Can't remove.\n", filename);
 		claminfo.notremoved++;
 	    } else {
 		mprintf("%s: Removed.\n", filename);
 		logg("%s: Removed.\n", filename);
 	    }
 	} else if (optl(opt, "move"))
             move_infected(filename, opt);
     }
     return ret;
 }
 
 /* it has guaranteed read access to the archive */
 int scancompressed(const char *filename, struct cl_node *root, const struct passwd *user, const struct optstruct *opt, const struct cl_limits *limits)
 {
 	int ret = 0;
 	char *tmpdir, *gendir, *userprg;
 	struct stat statbuf;
 
     stat(filename, &statbuf);
 
     if(!S_ISREG(statbuf.st_mode)) {
 	mprintf("^Suspected archive %s is not a regular file.\n", filename);
 	return 0; /* hmm ? */
     }
 
     /* check write access */
 

     tmpdir = getenv("TMPDIR");

 
     if(tmpdir == NULL)
 #ifdef P_tmpdir
 	tmpdir = P_tmpdir;
 #else
 	tmpdir = "/tmp";
 #endif
 

     if(checkaccess(tmpdir, UNPUSER, W_OK) != 1) {

 	mprintf("@Can't write to the temporary directory.\n");
 	exit(64);
     }
 
     /* generate the temporary directory */
 

     gendir = cli_gentemp(tmpdir);

     if(mkdir(gendir, 0700)) {
 	mprintf("@Can't create the temporary directory %s\n", gendir);
 	exit(63); /* critical */
     }
 
     if(user)
 	chown(gendir, user->pw_uid, user->pw_gid);
 
 
     /* unpack file  - as unprivileged user */

     if(cli_strbcasestr(filename, ".zip")) {

 	char *args[] = { "unzip", "-P", "clam", "-o", (char *) filename, NULL };
 
 	if((userprg = getargl(opt, "unzip")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("unzip", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".rar")) { 

 	char *args[] = { "unrar", "x", "-p-", "-y", (char *) filename, NULL };
 	if((userprg = getargl(opt, "unrar")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("unrar", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".arj")) { 

         char *args[] = { "arj", "x","-y", (char *) filename, NULL };
         if((userprg = getargl(opt, "arj")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("arj", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".zoo")) { 

 	char *args[] = { "unzoo", "-x","-j","./", (char *) filename, NULL };
 	if((userprg = getargl(opt, "unzoo")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("unzoo", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".jar")) { 

 	char *args[] = { "unzip", "-P", "clam", "-o", (char *) filename, NULL };
 	if((userprg = getargl(opt, "jar")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("unzip", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".lzh")) { 

 	char *args[] = { "lha", "xf", (char *) filename, NULL };
 	if((userprg = getargl(opt, "lha")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("lha", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".tar")) { 

 	char *args[] = { "tar", "-xpvf", (char *) filename, NULL };
 	if((userprg = getargl(opt, "tar")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("tar", args, gendir, user, opt);
 

     } else if(cli_strbcasestr(filename, ".deb")) { 

 	char *args[] = { "ar", "x", (char *) filename, NULL };
 	if((userprg = getargl(opt, "deb")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("ar", args, gendir, user, opt);
 

     } else if((cli_strbcasestr(filename, ".tar.gz") || cli_strbcasestr(filename, ".tgz"))) {

 	char *args[] = { "tar", "-zxpvf", (char *) filename, NULL };
 	if((userprg = getargl(opt, "tgz")))
 	    ret = clamav_unpack(userprg, args, gendir, user, opt);
 	else
 	    ret = clamav_unpack("tar", args, gendir, user, opt);
     }
 
     /* fix permissions of extracted files */
     fixperms(gendir);
 
     if(!ret) /* execute successful */
 	ret = treewalk(gendir, root, user, opt, limits);
 
     /* remove the directory  - as clamav */
     clamav_rmdirs(gendir);
 
     /* free gendir - it's not necessary now */
     free(gendir);
 
     switch(ret) {
 	case -1:
 	    mprintf("@Can't fork().\n");
 	    exit(61); /* this is critical problem, so we just exit here */
 	case -2:
 	    mprintf("@Can't execute some unpacker. Check paths and permissions on the temporary directory.\n");
 	    /* This is no longer a critical error (since 0.24). We scan
 	     * raw archive.
 	     */
 	    if(!printinfected)
 		mprintf("(raw) ");
 
 	    if((ret = checkfile(filename, root, limits, 0)) == CL_VIRUS) {
 		if(optl(opt, "remove")) {
 		    if(unlink(filename)) {
 			mprintf("%s: Can't remove.\n", filename);
 			logg("%s: Can't remove.\n", filename);
 			claminfo.notremoved++;
 		    } else {
 			mprintf("%s: Removed.\n", filename);
 			logg("%s: Removed.\n", filename);
 		    }
 		} else if (optl(opt, "move"))
 		    move_infected(filename, opt);
 	    }
 	    return ret;
 	case -3:
 	    return 0;
 	case 0:
 	    /* no viruses found in archive, we scan just in case the same
 	     * archive
 	     */
 	    if(!printinfected)
 		mprintf("(raw) ");
 
 	    if((ret = checkfile(filename, root, limits, 0)) == CL_VIRUS) {
 		if(optl(opt, "remove")) {
 		    if(unlink(filename)) {
 			mprintf("%s: Can't remove.\n", filename);
 			logg("%s: Can't remove.\n", filename);
 			claminfo.notremoved++;
 		    } else {
 			mprintf("%s: Removed.\n", filename);
 			logg("%s: Removed.\n", filename);
 		    }
 		} else if (optl(opt, "move"))
 		    move_infected(filename, opt);
 	    }
 	    return ret;
 	case 1:
 	    logg("%s: Infected Archive FOUND\n", filename);
 	    mprintf("%s: Infected Archive FOUND\n", filename);

 
 	    if(bell)

 		fprintf(stderr, "\007");

 	    if(optl(opt, "remove")) {
 		if(unlink(filename)) {
 		    mprintf("%s: Can't remove.\n", filename);
 		    logg("%s: Can't remove.\n", filename);
 		    claminfo.notremoved++;
 		} else {
 		    mprintf("%s: Removed.\n", filename);
 		    logg("%s: Removed.\n", filename);
 		}
 	    } else if (optl(opt, "move"))
 		move_infected(filename, opt);
 
 	    return 1;
 	default:
 	    mprintf("@Strange value (%d) returned in scancompressed()\n", ret);
 	    return 0;
     }
 }
 
 int scandenied(const char *filename, struct cl_node *root, const struct passwd *user, const struct optstruct *opt, const struct cl_limits *limits)
 {
 	char *tmpdir, *gendir, *tmpfile, *pt;
 	struct stat statbuf;
 	int ret;
 
     stat(filename, &statbuf);
     if(!S_ISREG(statbuf.st_mode)) {
 	mprintf("^Suspected archive %s is not a regular file.\n", filename);
 	return 0;
     }
 
     /* check write access */
 

     tmpdir = getenv("TMPDIR");

 
     if(tmpdir == NULL)
 #ifdef P_tmpdir
 	tmpdir = P_tmpdir;
 #else
 	tmpdir = "/tmp";
 #endif
 
 

     if(checkaccess(tmpdir, UNPUSER, W_OK) != 1) {

 	mprintf("@Can't write to the temporary directory %s.\n", tmpdir);
 	exit(64);
     }
 
     /* generate the temporary directory */

     gendir = cli_gentemp(tmpdir);

     if(mkdir(gendir, 0700)) {
 	mprintf("@Can't create the temporary directory %s\n", gendir);
 	exit(63); /* critical */
     }
 
     tmpfile = (char *) mcalloc(strlen(gendir) + strlen(filename) + 10, sizeof(char));
     pt = strrchr(filename, '/');
     if(!pt)
 	pt = (char *) filename;
     else
 	pt += 1;
 
     sprintf(tmpfile, "%s/%s", gendir, pt);
 
     if(filecopy(filename, tmpfile) == -1) {
 	mprintf("!I/O error.\n");
 	perror("copyfile()");
 	exit(58);
     }
 
     fixperms(gendir);
 
     if(user) {
 	chown(gendir, user->pw_uid, user->pw_gid);
 	chown(tmpfile, user->pw_uid, user->pw_gid);
     }
 
     if((ret = treewalk(gendir, root, user, opt, limits)) == 1) {
 	logg("(Real infected archive: %s)\n", filename);
 	mprintf("(Real infected archive: %s)\n", filename);
 
 	if(optl(opt, "remove")) {
 	    if(unlink(filename)) {
 		mprintf("%s: Can't remove.\n", filename);
 		logg("%s: Can't remove.\n", filename);
 		claminfo.notremoved++;
 	    } else {
 	        mprintf("%s: Removed.\n", filename);
 	        logg("%s: Removed.\n", filename);
 	    }
 	} else if (optl(opt, "move"))
 	    move_infected(filename, opt);
     }
 
     /* remove the directory  - as clamav */
     clamav_rmdirs(gendir);
 
     free(gendir);
     free(tmpfile);
 
     return ret;
 }
 
 int scandirs(const char *dirname, struct cl_node *root, const struct passwd *user, const struct optstruct *opt, const struct cl_limits *limits)
 {
 	return treewalk(dirname, root, user, opt, limits);
 }
 
 int checkfile(const char *filename, const struct cl_node *root, const struct cl_limits *limits, int options)
 {
 	int fd, ret;

 	const char *virname;

 
     mprintf("*Scanning %s\n", filename);
 

     if((fd = open(filename, O_RDONLY)) == -1) {
 	mprintf("@Can't open file %s\n", filename);
 	return 54;
     }
 
     claminfo.files++;
 
     if((ret = cl_scandesc(fd, &virname, &claminfo.blocks, root, limits, options)) == CL_VIRUS) {
 	mprintf("%s: %s FOUND\n", filename, virname);
 	logg("%s: %s FOUND\n", filename, virname);
 	claminfo.ifiles++;

 
 	if(bell)

 	    fprintf(stderr, "\007");

     } else if(ret == CL_CLEAN) {
 	if(!printinfected)
 	    mprintf("%s: OK\n", filename);
     } else
 	if(!printinfected)

 	    mprintf("%s: %s\n", filename, cl_strerror(ret));

 
     close(fd);
     return ret;
 }
 
 int checkstdin(const struct cl_node *root, const struct cl_limits *limits)
 {
 	int ret;

 	const char *virname;

 
 
     claminfo.files++;
 
     if((ret = cl_scandesc(0, &virname, &claminfo.blocks, root, limits, CL_RAW)) == CL_VIRUS) {
 	mprintf("stdin: %s FOUND\n", virname);
 	claminfo.ifiles++;

 
 	if(bell)

 	    fprintf(stderr, "\007");

     } else if(ret == CL_CLEAN) {
 	if(!printinfected)
 	    mprintf("stdin: OK\n");
     } else
 	if(!printinfected)

 	    mprintf("stdin: %s\n", cl_strerror(ret));

 
     return ret;
 }
 
 /*
  * -1 -> can't fork
  * -2 -> can't execute
  * -3 -> external signal
  * 0 -> OK
  */
 
 int clamav_unpack(const char *prog, char **args, const char *tmpdir, const struct passwd *user, const struct optstruct *opt)
 {
 	pid_t pid;
 	int status, wret, maxfiles, maxspace, fdevnull;
 	struct s_du n;
 
 
     if(optl(opt, "max-files"))
 	maxfiles = atoi(getargl(opt, "max-files"));
     else
 	maxfiles = 0;
 
     if(optl(opt, "max-space")) {
 	    char *cpy, *ptr;
 	ptr = getargl(opt, "max-space");
 	if(tolower(ptr[strlen(ptr) - 1]) == 'm') { /* megabytes */
 	    cpy = mcalloc(strlen(ptr), sizeof(char));

 	    strncpy(cpy, ptr, strlen(ptr) - 1);

 	    maxspace = atoi(cpy) * 1024;
 	    free(cpy);
 	} else /* default - kilobytes */
 	    maxspace = atoi(ptr);
     } else
 	maxspace = 0;
 
 
     switch(pid = fork()) {
 	case -1:
 	    return -1;
 	case 0:
 #ifndef C_CYGWIN

 	    if(!geteuid() && user) {

 
 #ifdef HAVE_SETGROUPS

 		if(setgroups(1, &user->pw_gid)) {
 		    fprintf(stderr, "ERROR: setgroups() failed.\n");
 		    exit(1);
 		}

 #endif

 
 		if(setgid(user->pw_gid)) {
 		    fprintf(stderr, "ERROR: setgid(%d) failed.\n", (int) user->pw_gid);
 		    exit(1);
 		}
 
 		if(setuid(user->pw_uid)) {
 		    fprintf(stderr, "ERROR: setuid(%d) failed.\n", (int) user->pw_uid);
 		    exit(1);
 		}

 	    }
 #endif
 	    chdir(tmpdir);
 
 	    if(printinfected) {
   	        fdevnull = open("/dev/null", O_WRONLY);
 		if(fdevnull == -1) {
 		    mprintf("Non fatal error: cannot open /dev/null. Continuing with full output\n");
 		    printinfected = 0;
 		} else {
 		    dup2(fdevnull,1);
 		    dup2(fdevnull,2);
 		}
 	    }
 
 	    if(strchr(prog, '/')) /* we have full path */
 		execv(prog, args);
 	    else
 		execvp(prog, args);
 	    perror("execv(p)");
 	    abort();
 	    break;
 	default:
 
 	    if(maxfiles || maxspace) {
 		while(!(wret = waitpid(pid, &status, WNOHANG))) {
 		    memset(&n, 0, sizeof(struct s_du));
 
 		    if(!du(tmpdir, &n))
 			if((maxfiles && n.files > maxfiles) || (maxspace && n.space > maxspace)) {
 			    mprintf("*n.files: %d, n.space: %d\n", n.files, n.space);
 			    kill(pid, 9); /* stop it immediately */
 			}
 		}
 	    } else
 		waitpid(pid, &status, 0);
 
 
 	    if(WIFSIGNALED(status)) {
 		switch(WTERMSIG(status)) {
 
 		    case 9:
 			mprintf("\nUnpacker process %d stopped due to exceeded limits.\n", pid);
 			return 0;
 		    case 6: /* abort */
 			mprintf("@Can't run %s\n", prog);
 			return -2;
 		    default:
 			mprintf("@\nUnpacker stopped with external signal %d\n", WTERMSIG(status));
 			return -3;
 		}
 	    } else if(WIFEXITED(status))
 		return 0;
     }
 
     return 0;
 }
 
 void move_infected(const char *filename, const struct optstruct *opt)
 {

     char *movedir, *movefilename, *tmp, numext[4 + 1];

     struct stat fstat, mfstat;

     int n, len, movefilename_size;

 
     if(!(movedir = getargl(opt, "move"))) {

         /* Should never reach here */
         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: getargc() returned NULL.\n");
         logg("clamscan: getargc() returned NULL.\n");
         claminfo.notmoved++;
         return;
     }
 

     if(access(movedir, W_OK|X_OK) == -1) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: cannot write to '%s': %s.\n", movedir, strerror(errno));
         logg("clamscan: cannot write to '%s': %s.\n", movedir, strerror(errno));
         claminfo.notmoved++;
         return;
     }

 
     if(!(tmp = strrchr(filename, '/'))) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: '%s' does not appear to be a valid filename.\n", filename);
         logg("clamscan: '%s' does not appear to be a valid filename.\n", filename);
         claminfo.notmoved++;
         return;
     }

 
     movefilename_size = sizeof(char) * (strlen(movedir) + strlen(tmp) + sizeof(numext) + 1);
 
     if(!(movefilename = malloc(movefilename_size))) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: malloc() returned NULL.\n");
         logg("clamscan: malloc() returned NULL.\n");
         claminfo.notmoved++;
         return;
     }

 
     if(!(strrcpy(movefilename, movedir))) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: strrcpy() returned NULL.\n");
         logg("clamscan: strrcpy() returned NULL.\n");
         claminfo.notmoved++;
         free(movefilename);
         return;
     }

 
     if(!(strcat(movefilename, tmp))) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: strcat() returned NULL.\n");
         logg("clamscan: strcat() returned NULL.\n");
         claminfo.notmoved++;
         free(movefilename);
         return;
     }

     stat(filename, &fstat);
 

     if(!stat(movefilename, &mfstat)) {

         if(fstat.st_ino == mfstat.st_ino) { /* It's the same file*/
             mprintf("clamscan: file excluded '%s'.\n", filename);
             logg("clamscan: file excluded '%s'.\n", filename);
             claminfo.notmoved++;
             free(movefilename);
             return;

         } else {
             /* file exists - try to append an ordinal number to the
 	     * quranatined file in an attempt not to overwrite existing
 	     * files in quarantine  
 	     */
             len = strlen(movefilename);
             n = 0;        		        		
             do {
                 /* reset the movefilename to it's initial value by
 		 * truncating to the original filename length
 		 */
                 movefilename[len] = 0;
                 /* append .XXX */
                 sprintf(numext, ".%03d", n++);
                 strcat(movefilename, numext);            	
             } while(!stat(movefilename, &mfstat) && (n < 1000));
        }

     }

 
     if(filecopy(filename, movefilename) == -1) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: cannot move '%s' to '%s': %s.\n", filename, movefilename, strerror(errno));
         logg("clamscan: cannot move '%s' to '%s': %s.\n", filename, movefilename, strerror(errno));
         claminfo.notmoved++;
         free(movefilename);
         return;
     }
 
     chmod(movefilename, fstat.st_mode);
     chown(movefilename, fstat.st_uid, fstat.st_gid);

 
     if(unlink(filename)) {

         mprintf("@error moving file '%s'.\n", filename);
         mprintf("clamscan: cannot unlink '%s': %s.\n", filename, strerror(errno));
         logg("clamscan: cannot unlink '%s': %s.\n", filename, strerror(errno));
         claminfo.notremoved++;            

     } else {

         mprintf("%s: moved to '%s'.\n", filename, movefilename);
         logg("%s: moved to '%s'.\n", filename, movefilename);
     }
 
     free(movefilename);
 }