/*

  *  Copyright (C) 2013-2020 Cisco Systems, Inc. and/or its affiliates. All rights reserved.

  *  Copyright (C) 2007-2013 Sourcefire, Inc.

  *
  *  Authors: Tomasz Kojm

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

  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.

  *
  *  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., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.

  */
 
 #if HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 
 #include <stdio.h>

 #include <stdlib.h>

 #ifdef HAVE_UNISTD_H

 #include <unistd.h>

 #endif

 #include <string.h>

 #include <time.h>

 #include <sys/types.h>
 #include <sys/stat.h>

 #ifndef _WIN32

 #include <sys/socket.h>

 #include <pwd.h>
 #include <grp.h>
 #include <sys/types.h>

 #endif

 #include <dirent.h>

 #include <fcntl.h>

 #include <ctype.h>

 #include <errno.h>

 // libclamav
 #include "clamav.h"
 #include "cvd.h"
 #include "others.h" /* for cli_rmdirs() */
 #include "regex/regex.h"
 #include "version.h"

 #include "optparser.h"
 #include "output.h"
 #include "misc.h"

 #include <signal.h>
 
 #ifndef WIN32
 #include <sys/wait.h>
 #endif
 

 #ifndef REPO_VERSION
 #define REPO_VERSION "exported"
 #endif
 
 const char *get_version(void)
 {

     if (!strncmp("devel-", VERSION, 6) && strcmp("exported", REPO_VERSION)) {
         return REPO_VERSION "" VERSION_SUFFIX;
     }
     /* it is a release, or we have nothing better */
     return VERSION "" VERSION_SUFFIX;

 }

 char *freshdbdir(void)
 {

     struct cl_cvd *d1, *d2;
     struct optstruct *opts;
     const struct optstruct *opt;
     const char *dbdir;
     char *retdir;

 
     /* try to find the most up-to-date db directory */
     dbdir = cl_retdbdir();

     if ((opts = optparse(CONFDIR_FRESHCLAM, 0, NULL, 0, OPT_FRESHCLAM, 0, NULL))) {
         if ((opt = optget(opts, "DatabaseDirectory"))->enabled) {
             if (strcmp(dbdir, opt->strarg)) {
                 char *daily = (char *)malloc(strlen(opt->strarg) + strlen(dbdir) + 30);
                 if (daily == NULL) {
                     fprintf(stderr, "Unable to allocate memory for db directory...\n");
                     return NULL;
                 }
                 sprintf(daily, "%s" PATHSEP "daily.cvd", opt->strarg);
                 if (access(daily, R_OK))
                     sprintf(daily, "%s" PATHSEP "daily.cld", opt->strarg);
 
                 if (!access(daily, R_OK) && (d1 = cl_cvdhead(daily))) {
                     sprintf(daily, "%s" PATHSEP "daily.cvd", dbdir);
                     if (access(daily, R_OK))
                         sprintf(daily, "%s" PATHSEP "daily.cld", dbdir);
 
                     if (!access(daily, R_OK) && (d2 = cl_cvdhead(daily))) {
                         free(daily);
                         if (d1->version > d2->version)
                             dbdir = opt->strarg;
                         cl_cvdfree(d2);
                     } else {
                         free(daily);
                         dbdir = opt->strarg;
                     }
                     cl_cvdfree(d1);
                 } else {
                     free(daily);
                 }
             }
         }

     }
 
     retdir = strdup(dbdir);
 

     if (opts)
         optfree(opts);

 
     return retdir;
 }
 
 void print_version(const char *dbdir)
 {

     char *fdbdir = NULL, *path;
     const char *pt;
     struct cl_cvd *daily;
     time_t db_time;
     unsigned int db_version = 0;
 
     if (dbdir)
         pt = dbdir;

     else

         pt = fdbdir = freshdbdir();

     if (!pt) {
         printf("ClamAV %s\n", get_version());
         return;

     }
 

     if (!(path = malloc(strlen(pt) + 11))) {
         if (!dbdir)
             free(fdbdir);
         return;

     }
 

     sprintf(path, "%s" PATHSEP "daily.cvd", pt);
     if (!access(path, R_OK)) {
         daily = cl_cvdhead(path);
         if (daily) {
             db_version = daily->version;
             db_time    = daily->stime;
             cl_cvdfree(daily);
         }

     }
 

     sprintf(path, "%s" PATHSEP "daily.cld", pt);
     if (!access(path, R_OK)) {
         daily = cl_cvdhead(path);
         if (daily) {
             if (daily->version > db_version) {
                 db_version = daily->version;
                 db_time    = daily->stime;
             }
             cl_cvdfree(daily);
         }

     }
 

     if (!dbdir)
         free(fdbdir);

     if (db_version) {
         printf("ClamAV %s/%u/%s", get_version(), db_version, ctime(&db_time));

     } else {

         printf("ClamAV %s\n", get_version());

     }
 
     free(path);
 }
 
 int check_flevel(void)
 {

     if (cl_retflevel() < CL_FLEVEL) {
         fprintf(stderr, "ERROR: This tool requires libclamav with functionality level %u or higher (current f-level: %u)\n", CL_FLEVEL, cl_retflevel());
         return 1;

     }
     return 0;
 }
 

 const char *filelist(const struct optstruct *opts, int *err)
 {

     static char buff[1025];
     static unsigned int cnt = 0;
     const struct optstruct *opt;
     static FILE *fs = NULL;
     size_t len;
 
     if (!cnt && (opt = optget(opts, "file-list"))->enabled) {
         if (!fs) {
             fs = fopen(opt->strarg, "r");
             if (!fs) {
                 fprintf(stderr, "ERROR: --file-list: Can't open file %s\n", opt->strarg);
                 if (err)
                     *err = 54;
                 return NULL;
             }
         }
 
         if (fgets(buff, 1024, fs)) {
             buff[1024] = 0;
             len        = strlen(buff);
             if (!len) {
                 fclose(fs);
                 return NULL;
             }
             len--;
             while (len && ((buff[len] == '\n') || (buff[len] == '\r')))
                 buff[len--] = '\0';
             return buff;
         } else {
             fclose(fs);
             return NULL;
         }

     }
 
     return opts->filename ? opts->filename[cnt++] : NULL;
 }
 

 int filecopy(const char *src, const char *dest)
 {

 #ifdef _WIN32
     return (!CopyFileA(src, dest, 0));
 #elif defined(C_DARWIN)

     pid_t pid;

     /* On Mac OS X use ditto and copy resource fork, too. */

     switch (pid = fork()) {
         case -1:
             return -1;
         case 0:
             execl("/usr/bin/ditto", "ditto", src, dest, NULL);
             perror("execl(ditto)");
             break;
         default:
             wait(NULL);
             return 0;

     }
 

     return -1;

 #else /* C_DARWIN */
     return cli_filecopy(src, dest);

 #endif
 }

 #ifndef _WIN32
 int close_std_descriptors()
 {

     int fds[3], i;

     fds[0] = open("/dev/null", O_RDONLY);
     fds[1] = open("/dev/null", O_WRONLY);
     fds[2] = open("/dev/null", O_WRONLY);

     if (fds[0] == -1 || fds[1] == -1 || fds[2] == -1) {
         fputs("Can't open /dev/null\n", stderr);
         for (i = 0; i <= 2; i++)
             if (fds[i] != -1)
                 close(fds[i]);
         return -1;

     }

     for (i = 0; i <= 2; i++) {
         if (dup2(fds[i], i) == -1) {
             fprintf(stderr, "dup2(%d, %d) failed\n", fds[i], i); /* may not be printed */
             for (i = 0; i <= 2; i++)
                 if (fds[i] != -1)
                     close(fds[i]);
             return -1;
         }

     }
 

     for (i = 0; i <= 2; i++)
         if (fds[i] > 2)
             close(fds[i]);

     return 0;
 }
 

 int daemonize_all_return(void)
 {

     pid_t pid;
 

     pid = fork();
 

     if (0 == pid) {

         setsid();
     }
     return pid;
 }
 

 int daemonize(void)
 {

     int ret = 0;

     ret = close_std_descriptors();

     if (ret) {

         return ret;
     }
 

     ret       = daemonize_all_return();
     pid_t pid = (pid_t)ret;

     /*parent process.*/

     if (pid > 0) {

         exit(0);

     }
 
     return pid;
 }

 static void daemonize_child_initialized_handler(int sig)
 {

     (void)(sig);
     exit(0);
 }
 

 int daemonize_parent_wait(const char * const user, const char * const log_file)

 {

     int daemonizePid = daemonize_all_return();
     if (daemonizePid == -1) {
         return -1;

     } else if (daemonizePid) { //parent

         /* The parent will wait until either the child process
          * exits, or signals the parent that it's initialization is
          * complete.  If it exits, it is due to an error condition,
          * so the parent should exit with the same error code as the child.
          * If the child signals the parent that initialization is complete, it
          * the parent will exit from the signal handler (initDoneSignalHandler)
          * with exit code 0.
          */
         struct sigaction sig;
         memset(&sig, 0, sizeof(sig));
         sigemptyset(&(sig.sa_mask));
         sig.sa_handler = daemonize_child_initialized_handler;
 

         if (0 != sigaction(SIGINT, &sig, NULL)) {

             perror("sigaction");
             return -1;
         }
 

         if (NULL != user){
             if (drop_privileges(user, log_file)){
                 return -1;
             }
         }
 

         int exitStatus;
         wait(&exitStatus);

         if (WIFEXITED(exitStatus)) { //error

             exitStatus = WEXITSTATUS(exitStatus);
             exit(exitStatus);
         }
     }

     return 0;

 }

 void daemonize_signal_parent(pid_t parentPid)
 {

     close_std_descriptors();

     kill(parentPid, SIGINT);

 }

 
 int drop_privileges( const char * const user_name, const char * const log_file) {
     int ret = 1;
 
     /*This function is called in a bunch of places, and rather than change the error checking
      * in every function, we are just going to return success if there is no work to do.
      */
     if ((0 == geteuid()) && (NULL != user_name)){
         struct passwd *user = NULL;
 
         if ((user = getpwnam(user_name)) == NULL) {
             logg("^Can't get information about user %s.\n", user_name);
             fprintf(stderr, "ERROR: Can't get information about user %s.\n", user_name);
             goto done;
         }
 
 #ifdef HAVE_INITGROUPS
         if (initgroups(user_name, user->pw_gid)) {
             fprintf(stderr, "ERROR: initgroups() failed.\n");
             logg("^initgroups() failed.\n");
             goto done;
         }
 #elif HAVE_SETGROUPS
         if (setgroups(1, &user->pw_gid)) {
             fprintf(stderr, "ERROR: setgroups() failed.\n");
             logg("^setgroups() failed.\n");
             goto done;
         }

 #endif

         /*Change ownership of the log file to the user we are going to switch to.*/
         if (NULL != log_file){
             int ret = lchown(log_file, user->pw_uid, user->pw_gid);
             if (ret){
                 fprintf(stderr, "ERROR: lchown to user '%s' failed on\n", user->pw_name);
                 fprintf(stderr, "log file '%s'.\n", log_file);
                 fprintf(stderr, "Error was '%s'\n", strerror(errno));
                 logg("^lchown to user '%s' failed on log file '%s'.  Error was '%s'\n", 
                         user->pw_name, log_file, strerror(errno));
                 goto done;
             }
         }
 
         if (setgid(user->pw_gid)) {
             fprintf(stderr, "ERROR: setgid(%d) failed.\n", (int)user->pw_gid);
             logg("^setgid(%d) failed.\n", (int)user->pw_gid);
             goto done;
         }
 
         if (setuid(user->pw_uid)) {
             fprintf(stderr, "ERROR: setuid(%d) failed.\n", (int)user->pw_uid);
             logg("^setuid(%d) failed.\n", (int)user->pw_uid);
             goto done;
         }
     }
     ret = 0;
 
 done:
     return ret;
 }
 #endif /*_WIN32*/
 

 int match_regex(const char *filename, const char *pattern)
 {

     regex_t reg;
     int match, flags = REG_EXTENDED | REG_NOSUB;
     char fname[513];

 #ifdef _WIN32

     flags |= REG_ICASE; /* case insensitive on Windows */

 #endif

     if (cli_regcomp(&reg, pattern, flags) != 0)
         return 2;
 
     if (pattern[strlen(pattern) - 1] == *PATHSEP) {
         snprintf(fname, 511, "%s" PATHSEP, filename);
         fname[512] = 0;
     } else {
         strncpy(fname, filename, 513);
         fname[512] = '\0';
     }
 
     match = (cli_regexec(&reg, fname, 0, NULL, 0) == REG_NOMATCH) ? 0 : 1;
     cli_regfree(&reg);
     return match;

 }

 int cli_is_abspath(const char *path)
 {

 #ifdef _WIN32
     int len = strlen(path);

     return (len > 2 && path[0] == '\\' && path[1] == '\\') || (len >= 2 && ((*path >= 'a' && *path <= 'z') || (*path >= 'A' && *path <= 'Z')) && path[1] == ':');

 #else
     return *path == '/';
 #endif
 }

 
 unsigned int countlines(const char *filename)
 {

     FILE *fh;
     char buff[1024];
     unsigned int lines = 0;

     if ((fh = fopen(filename, "r")) == NULL)
         return 0;

     while (fgets(buff, sizeof(buff), fh)) {
         if (buff[0] == '#') continue;
         lines++;

     }
 
     fclose(fh);
     return lines;
 }