/*

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

  *

  *  Authors: Mickey Sola

  *
  *  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 <string.h>
 #include <stdlib.h>

 #include <pthread.h>
 #include <signal.h>

 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifndef _WIN32
 #include <sys/time.h>
 #endif
 #include <time.h>
 #include <signal.h>

 #if defined(FANOTIFY)
 #include <sys/fanotify.h>
 #include <fcntl.h>
 #endif

 #include "libclamav/clamav.h"
 #include "libclamav/others.h"
 #include "shared/output.h"
 #include "shared/misc.h"
 #include "shared/optparser.h"
 #include "shared/actions.h"

 #include "clamonacc.h"
 #include "client/client.h"
 #include "fanotif/fanotif.h"
 #include "inotif/inotif.h"
 #include "scan/queue.h"

 pthread_t ddd_pid        = 0;

 pthread_t scan_queue_pid = 0;

 static void onas_handle_signals();

 static int startup_checks(struct onas_context *ctx);

 static struct onas_context *g_ctx = NULL;
 
 static void onas_clamonacc_exit(int sig)
 {

     logg("*Clamonacc: onas_clamonacc_exit(), signal %d\n", sig);
     if (sig == 11) {
         logg("!Clamonacc: clamonacc has experienced a fatal error, if you continue to see this error, please run clamonacc with --debug and report the issue and crash report to the developpers\n");
     }
 
     if (g_ctx) {
         if (g_ctx->fan_fd) {
             close(g_ctx->fan_fd);
         }
         g_ctx->fan_fd = 0;
     }
 
     logg("*Clamonacc: attempting to stop event consumer thread ...\n");
     if (scan_queue_pid > 0) {
         pthread_cancel(scan_queue_pid);
         pthread_join(scan_queue_pid, NULL);
     }
     scan_queue_pid = 0;
 
     logg("*Clamonacc: attempting to stop ddd thread ... \n");
     if (ddd_pid > 0) {
         pthread_cancel(ddd_pid);
         pthread_join(ddd_pid, NULL);
     }
     ddd_pid = 0;
 
     logg("Clamonacc: stopped\n");
     onas_cleanup(g_ctx);
     pthread_exit(NULL);

 }

 int main(int argc, char **argv)
 {

     const struct optstruct *opts;
     const struct optstruct *clamdopts;
     struct onas_context *ctx;
     int ret = 0;
 
     /* Initialize context */
     ctx = onas_init_context();
     if (ctx == NULL) {
         logg("!Clamonacc: can't initialize context\n");
         return 2;
     }
 
     /* Parse out all our command line options */
     opts = optparse(NULL, argc, argv, 1, OPT_CLAMONACC, OPT_CLAMSCAN, NULL);
     if (opts == NULL) {
         logg("!Clamonacc: can't parse command line options\n");
         return 2;
     }
     ctx->opts = opts;
 
     /* And our config file options */
     clamdopts = optparse(optget(opts, "config-file")->strarg, 0, NULL, 1, OPT_CLAMD, 0, NULL);
     if (clamdopts == NULL) {
         logg("!Clamonacc: can't parse clamd configuration file %s\n", optget(opts, "config-file")->strarg);
         return 2;
     }
     ctx->clamdopts = clamdopts;
 
     /* Make sure we're good to begin spinup */
     ret = startup_checks(ctx);
     if (ret) {
         goto clean_up;
     }

 
 #ifndef _WIN32

     /* Daemonize if sanity checks are good to go */
     if (!optget(ctx->opts, "foreground")->enabled) {
         if (-1 == daemonize()) {
             logg("!Clamonacc: could not daemonize\n");
             return 2;

         }

     }

 #endif
 

     /* Setup our client */
     switch (onas_setup_client(&ctx)) {
         case CL_SUCCESS:
             if (CL_SUCCESS == onas_check_client_connection(&ctx)) {
                 break;
             }
         case CL_BREAK:
             ret = 0;
             logg("*Clamonacc: not setting up client\n");
             goto clean_up;
             break;
         case CL_EARG:
         default:
             logg("!Clamonacc: can't setup client\n");
             ret = 2;
             goto clean_up;
             break;
     }
 
     /* Setup our event queue */
     ctx->maxthreads = optget(ctx->clamdopts, "OnAccessMaxThreads")->numarg;
 
     switch (onas_scan_queue_start(&ctx)) {
         case CL_SUCCESS:
             break;
         case CL_BREAK:
         case CL_EARG:
         case CL_ECREAT:
         default:
             ret = 2;
             logg("!Clamonacc: can't setup event consumer queue\n");
             goto clean_up;
             break;
     }
 
 #if defined(FANOTIFY)
     /* Setup fanotify */
     switch (onas_setup_fanotif(&ctx)) {
         case CL_SUCCESS:
             break;
         case CL_BREAK:
             ret = 0;
             goto clean_up;
             break;
         case CL_EARG:
         default:
             mprintf("!Clamonacc: can't setup fanotify\n");
             ret = 2;
             goto clean_up;
             break;
     }
 
     if (ctx->ddd_enabled) {
         /* Setup inotify and kickoff DDD system */
         switch (onas_enable_inotif_ddd(&ctx)) {

             case CL_SUCCESS:
                 break;
             case CL_BREAK:

                 ret = 0;
                 goto clean_up;
                 break;

             case CL_EARG:
             default:

                 mprintf("!Clamonacc: can't setup fanotify\n");

                 ret = 2;
                 goto clean_up;
                 break;
         }

     }

 #else

     mprintf("!Clamonacc: currently, this application only runs on linux systems with fanotify enabled\n");
     goto clean_up;

 #endif

     /* Setup signal handling */
     g_ctx = ctx;
     onas_handle_signals();

     logg("*Clamonacc: beginning event loops\n");
     /*  Kick off event loop(s) */
     ret = onas_start_eloop(&ctx);

     /* Clean up */

 clean_up:

     onas_cleanup(ctx);
     exit(ret);

 }

 static void onas_handle_signals()
 {
     sigset_t sigset;
     struct sigaction act;
 
     /* ignore all signals except SIGUSR1 */
     sigfillset(&sigset);
     sigdelset(&sigset, SIGUSR1);
     sigdelset(&sigset, SIGUSR2);
     /* The behavior of a process is undefined after it ignores a

 	 * SIGFPE, SIGILL, SIGSEGV, or SIGBUS signal */

     sigdelset(&sigset, SIGFPE);
     sigdelset(&sigset, SIGILL);
     sigdelset(&sigset, SIGSEGV);
     sigdelset(&sigset, SIGINT);
     sigdelset(&sigset, SIGTERM);

 #ifdef SIGBUS

     sigdelset(&sigset, SIGBUS);

 #endif

     pthread_sigmask(SIG_SETMASK, &sigset, NULL);
     memset(&act, 0, sizeof(struct sigaction));
     act.sa_handler = onas_clamonacc_exit;
     sigfillset(&(act.sa_mask));
     sigaction(SIGUSR2, &act, NULL);
     sigaction(SIGTERM, &act, NULL);
     sigaction(SIGSEGV, &act, NULL);
     sigaction(SIGINT, &act, NULL);

 }
 

 struct onas_context *onas_init_context(void)
 {
     struct onas_context *ctx = (struct onas_context *)cli_malloc(sizeof(struct onas_context));

     if (NULL == ctx) {
         return NULL;

     }
 

     memset(ctx, 0, sizeof(struct onas_context));
     return ctx;
 }

 cl_error_t onas_check_client_connection(struct onas_context **ctx)
 {

     cl_error_t err = CL_SUCCESS;

     /* 0 local, non-zero remote, errno set on error */
     (*ctx)->isremote = onas_check_remote(ctx, &err);
     if (CL_SUCCESS == err) {
         logg("*Clamonacc: ");
         (*ctx)->isremote ? logg("*daemon is remote\n") : logg("*daemon is local\n");
     }
     return err ? CL_EACCES : CL_SUCCESS;

 }

 int onas_start_eloop(struct onas_context **ctx)
 {
     int ret = 0;

     if (!ctx || !*ctx) {
         mprintf("!Clamonacc: unable to start clamonacc. (bad context)\n");
         return CL_EARG;
     }

 #if defined(FANOTIFY)

     ret = onas_fan_eloop(ctx);

 #endif
 

     return ret;

 }
 

 static int startup_checks(struct onas_context *ctx)
 {

 #if defined(FANOTIFY)

     char faerr[128];

 #endif

     int ret        = 0;
     cl_error_t err = CL_SUCCESS;

     if (optget(ctx->opts, "help")->enabled) {
         help();
         ret = 2;
         goto done;
     }

     if (optget(ctx->opts, "version")->enabled) {
         onas_print_server_version(&ctx);
         ret = 2;
         goto done;
     }

 #if defined(FANOTIFY)

     ctx->fan_fd = fanotify_init(FAN_CLASS_CONTENT | FAN_UNLIMITED_QUEUE | FAN_UNLIMITED_MARKS, O_LARGEFILE | O_RDONLY);
     if (ctx->fan_fd < 0) {
         logg("!Clamonacc: fanotify_init failed: %s\n", cli_strerror(errno, faerr, sizeof(faerr)));
         if (errno == EPERM) {
             logg("!Clamonacc: clamonacc must have elevated permissions ... exiting ...\n");
         }
         ret = 2;
         goto done;
     }

 #endif
 

     if (curl_global_init(CURL_GLOBAL_NOTHING)) {
         ret = 2;
         goto done;
     }
 
     if (0 == onas_check_remote(&ctx, &err)) {
 
         if (CL_SUCCESS != err) {
             logg("!Clamonacc: daemon is local, but a connection could not be established\n");
             ret = 2;
             goto done;
         }
 
         if (!optget(ctx->clamdopts, "OnAccessExcludeUID")->enabled &&
             !optget(ctx->clamdopts, "OnAccessExcludeUname")->enabled && !optget(ctx->clamdopts, "OnAccessExcludeRootUID")->enabled) {
             logg("!Clamonacc: at least one of OnAccessExcludeUID, OnAccessExcludeUname, or OnAccessExcludeRootUID must be specified ... it is reccomended you exclude the clamd instance UID or uname to prevent infinite event scanning loops\n");
             ret = 2;
             goto done;
         }
     }

 done:

     return ret;

 }
 

 void help(void)
 {
     mprintf_stdout = 1;
 
     mprintf("\n");
     mprintf("           ClamAV: On Access Scanning Application and Client %s\n", get_version());
     mprintf("           By The ClamAV Team: https://www.clamav.net/about.html#credits\n");

     mprintf("           (C) 2019 Cisco Systems, Inc.\n");

     mprintf("\n");
     mprintf("    clamonacc [options] [file/directory/-]\n");
     mprintf("\n");
     mprintf("    --help                 -h          Show this help\n");
     mprintf("    --version              -V          Print version number and exit\n");
     mprintf("    --verbose              -v          Be verbose\n");
     mprintf("    --log=FILE             -l FILE     Save scanning output to FILE\n");

     mprintf("    --foreground           -F          Output to foreground and do not daemonize\n");

     mprintf("    --watch-list=FILE      -w FILE     Watch directories from FILE\n");

     mprintf("    --exclude-list=FILE   -e FILE     Exclude directories from FILE\n");

     mprintf("    --remove                           Remove infected files. Be careful!\n");
     mprintf("    --move=DIRECTORY                   Move infected files into DIRECTORY\n");
     mprintf("    --copy=DIRECTORY                   Copy infected files into DIRECTORY\n");
     mprintf("    --config-file=FILE                 Read configuration from FILE.\n");
     mprintf("    --allmatch             -z          Continue scanning within file after finding a match.\n");
     mprintf("    --fdpass                           Pass filedescriptor to clamd (useful if clamd is running as a different user)\n");
     mprintf("    --stream                           Force streaming files to clamd (for debugging and unit testing)\n");
     mprintf("\n");
 
     exit(0);
 }

 void *onas_cleanup(struct onas_context *ctx)
 {
     onas_context_cleanup(ctx);
     logg_close();

 }
 

 void *onas_context_cleanup(struct onas_context *ctx)
 {
     close(ctx->fan_fd);
     optfree((struct optstruct *)ctx->opts);
     optfree((struct optstruct *)ctx->clamdopts);
     ctx->opts      = NULL;
     ctx->clamdopts = NULL;
     free(ctx);

 }