/*      $OpenBSD: cvs.c,v 1.160 2021/01/27 07:18:16 deraadt Exp $       */
/*
 * Copyright (c) 2006, 2007 Joris Vink <joris@openbsd.org>
 * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
 * All rights reserved.
 *
 * 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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``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 AUTHOR 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.
 */

#include <sys/stat.h>

#include <ctype.h>
#include <errno.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <err.h>

#include "cvs.h"
#include "remote.h"
#include "hash.h"

extern char *__progname;

/* verbosity level: 0 = really quiet, 1 = quiet, 2 = verbose */
int verbosity = 2;

/* compression level used with zlib, 0 meaning no compression taking place */
int     cvs_compress = 0;
int     cvs_readrc = 1;         /* read .cvsrc on startup */
int     cvs_trace = 0;
int     cvs_nolog = 0;
int     cvs_readonly = 0;
int     cvs_readonlyfs = 0;
int     cvs_nocase = 0; /* set to 1 to disable filename case sensitivity */
int     cvs_noexec = 0; /* set to 1 to disable disk operations (-n option) */
int     cvs_cmdop;
int     cvs_umask = CVS_UMASK_DEFAULT;
int     cvs_server_active = 0;

char    *cvs_tagname = NULL;
char    *cvs_defargs;           /* default global arguments from .cvsrc */
char    *cvs_rootstr;
char    *cvs_rsh = CVS_RSH_DEFAULT;
char    *cvs_editor = CVS_EDITOR_DEFAULT;
char    *cvs_homedir = NULL;
char    *cvs_tmpdir = CVS_TMPDIR_DEFAULT;

struct cvsroot *current_cvsroot = NULL;
struct cvs_cmd *cmdp;                   /* struct of command we are running */

int             cvs_getopt(int, char **);
__dead void     usage(void);
static void     cvs_read_rcfile(void);

struct cvs_varhead cvs_variables;

struct wklhead temp_files;

void sighandler(int);
volatile sig_atomic_t cvs_quit = 0;
volatile sig_atomic_t sig_received = 0;

extern CVSENTRIES *current_list;

struct hash_table created_directories;
struct hash_table created_cvs_directories;

void
sighandler(int sig)
{
        sig_received = sig;

        switch (sig) {
        case SIGINT:
        case SIGTERM:
        case SIGPIPE:
                cvs_quit = 1;
                break;
        default:
                break;
        }
}

void
cvs_cleanup(void)
{
        cvs_log(LP_TRACE, "cvs_cleanup: removing locks");
        worklist_run(&repo_locks, worklist_unlink);

        cvs_log(LP_TRACE, "cvs_cleanup: removing temp files");
        worklist_run(&temp_files, worklist_unlink);

        if (cvs_server_path != NULL) {
                if (cvs_rmdir(cvs_server_path) == -1)
                        cvs_log(LP_ERR,
                            "warning: failed to remove server directory: %s",
                            cvs_server_path);
                free(cvs_server_path);
                cvs_server_path = NULL;
        }

        if (current_list != NULL)
                cvs_ent_close(current_list, ENT_SYNC);
}

__dead void
usage(void)
{
        (void)fprintf(stderr,
            "usage: %s [-flnQqRrtvw] [-d root] [-e editor] [-s var=val]\n"
            "           [-T tmpdir] [-z level] command ...\n", __progname);
        exit(1);
}

int
cvs_build_cmd(char ***cmd_argv, char **argv, int argc)
{
        int cmd_argc, i, cur;
        char *cp, *linebuf, *lp;

        if (cmdp->cmd_defargs == NULL) {
                *cmd_argv = argv;
                return argc;
        }

        cur = argc + 2;
        cmd_argc = 0;
        *cmd_argv = xcalloc(cur, sizeof(char *));
        (*cmd_argv)[cmd_argc++] = argv[0];

        linebuf = xstrdup(cmdp->cmd_defargs);
        for (lp = linebuf; lp != NULL;) {
                cp = strsep(&lp, " \t\b\f\n\r\t\v");
                if (cp == NULL)
                        break;
                if (*cp == '\0')
                        continue;

                if (cmd_argc == cur) {
                        cur += 8;
                        *cmd_argv = xreallocarray(*cmd_argv, cur,
                            sizeof(char *));
                }

                (*cmd_argv)[cmd_argc++] = cp;
        }

        if (cmd_argc + argc > cur) {
                cur = cmd_argc + argc + 1;
                *cmd_argv = xreallocarray(*cmd_argv, cur,
                    sizeof(char *));
        }

        for (i = 1; i < argc; i++)
                (*cmd_argv)[cmd_argc++] = argv[i];

        (*cmd_argv)[cmd_argc] = NULL;

        return cmd_argc;
}

int
main(int argc, char **argv)
{
        char *envstr, **cmd_argv, **targv;
        int i, ret, cmd_argc;
        struct passwd *pw;
        struct stat st;
        char fpath[PATH_MAX];

        if (pledge("stdio rpath wpath cpath fattr getpw proc exec", NULL) == -1)
                err(1, "pledge");

        tzset();

        TAILQ_INIT(&cvs_variables);
        SLIST_INIT(&repo_locks);
        SLIST_INIT(&temp_files);

        hash_table_init(&created_directories, 100);
        hash_table_init(&created_cvs_directories, 100);

        /* check environment so command-line options override it */
        if ((envstr = getenv("CVS_RSH")) != NULL)
                cvs_rsh = envstr;

        if (((envstr = getenv("CVSEDITOR")) != NULL) ||
            ((envstr = getenv("VISUAL")) != NULL) ||
            ((envstr = getenv("EDITOR")) != NULL))
                cvs_editor = envstr;

        if ((envstr = getenv("CVSREAD")) != NULL)
                cvs_readonly = 1;

        if ((envstr = getenv("CVSREADONLYFS")) != NULL) {
                cvs_readonlyfs = 1;
                cvs_nolog = 1;
        }

        if ((cvs_homedir = getenv("HOME")) == NULL) {
                if ((pw = getpwuid(getuid())) != NULL)
                        cvs_homedir = pw->pw_dir;
        }

        if ((envstr = getenv("TMPDIR")) != NULL)
                cvs_tmpdir = envstr;

        ret = cvs_getopt(argc, argv);

        argc -= ret;
        argv += ret;
        if (argc == 0)
                usage();

        cmdp = cvs_findcmd(argv[0]);
        if (cmdp == NULL) {
                fprintf(stderr, "Unknown command: `%s'\n\n", argv[0]);
                fprintf(stderr, "CVS commands are:\n");
                for (i = 0; cvs_cdt[i] != NULL; i++)
                        fprintf(stderr, "\t%-16s%s\n",
                            cvs_cdt[i]->cmd_name, cvs_cdt[i]->cmd_descr);
                exit(1);
        }

        /*
         * check the tmp dir, either specified through
         * the environment variable TMPDIR, or via
         * the global option -T <dir>
         */
        if (stat(cvs_tmpdir, &st) == -1)
                fatal("stat failed on `%s': %s", cvs_tmpdir, strerror(errno));
        else if (!S_ISDIR(st.st_mode))
                fatal("`%s' is not valid temporary directory", cvs_tmpdir);

        if (cvs_readrc == 1 && cvs_homedir != NULL) {
                cvs_read_rcfile();

                if (cvs_defargs != NULL) {
                        if ((targv = cvs_makeargv(cvs_defargs, &i)) == NULL)
                                fatal("failed to load default arguments to %s",
                                    __progname);

                        cvs_getopt(i, targv);
                        cvs_freeargv(targv, i);
                        free(targv);
                }
        }

        /* setup signal handlers */
        signal(SIGTERM, sighandler);
        signal(SIGINT, sighandler);
        signal(SIGHUP, sighandler);
        signal(SIGABRT, sighandler);
        signal(SIGALRM, sighandler);
        signal(SIGPIPE, sighandler);

        cvs_cmdop = cmdp->cmd_op;

        cmd_argc = cvs_build_cmd(&cmd_argv, argv, argc);

        cvs_file_init();

        if (cvs_cmdop == CVS_OP_SERVER) {
                cmdp->cmd(cmd_argc, cmd_argv);
                cvs_cleanup();
                return (0);
        }

        cvs_umask = umask(0);
        umask(cvs_umask);

        if ((current_cvsroot = cvsroot_get(".")) == NULL) {
                cvs_log(LP_ERR,
                    "No CVSROOT specified! Please use the '-d' option");
                fatal("or set the CVSROOT environment variable.");
        }

        if (cvsroot_is_remote()) {
                cmdp->cmd(cmd_argc, cmd_argv);
                cvs_cleanup();
                return (0);
        }

        (void)xsnprintf(fpath, sizeof(fpath), "%s/%s",
            current_cvsroot->cr_dir, CVS_PATH_ROOT);

        if (stat(fpath, &st) == -1 && cvs_cmdop != CVS_OP_INIT) {
                if (errno == ENOENT)
                        fatal("repository '%s' does not exist",
                            current_cvsroot->cr_dir);
                else
                        fatal("%s: %s", current_cvsroot->cr_dir,
                            strerror(errno));
        } else {
                if (!S_ISDIR(st.st_mode))
                        fatal("'%s' is not a directory",
                            current_cvsroot->cr_dir);
        }

        if (cvs_cmdop != CVS_OP_INIT) {
                cvs_parse_configfile();
                cvs_parse_modules();
        }

        cmdp->cmd(cmd_argc, cmd_argv);
        cvs_cleanup();

        return (0);
}

int
cvs_getopt(int argc, char **argv)
{
        int ret;
        char *ep;
        const char *errstr;

        while ((ret = getopt(argc, argv, "b:d:e:flnQqRrs:T:tvwxz:")) != -1) {
                switch (ret) {
                case 'b':
                        /*
                         * We do not care about the bin directory for RCS files
                         * as this program has no dependencies on RCS programs,
                         * so it is only here for backwards compatibility.
                         */
                        cvs_log(LP_NOTICE, "the -b argument is obsolete");
                        break;
                case 'd':
                        cvs_rootstr = optarg;
                        break;
                case 'e':
                        cvs_editor = optarg;
                        break;
                case 'f':
                        cvs_readrc = 0;
                        break;
                case 'l':
                        cvs_nolog = 1;
                        break;
                case 'n':
                        cvs_noexec = 1;
                        cvs_nolog = 1;
                        break;
                case 'Q':
                        verbosity = 0;
                        break;
                case 'q':
                        if (verbosity > 1)
                                verbosity = 1;
                        break;
                case 'R':
                        cvs_readonlyfs = 1;
                        cvs_nolog = 1;
                        break;
                case 'r':
                        cvs_readonly = 1;
                        break;
                case 's':
                        ep = strchr(optarg, '=');
                        if (ep == NULL) {
                                cvs_log(LP_ERR, "no = in variable assignment");
                                exit(1);
                        }
                        *(ep++) = '\0';
                        if (cvs_var_set(optarg, ep) < 0)
                                exit(1);
                        break;
                case 'T':
                        cvs_tmpdir = optarg;
                        break;
                case 't':
                        cvs_trace = 1;
                        break;
                case 'v':
                        printf("%s\n", CVS_VERSION);
                        exit(0);
                        /* NOTREACHED */
                case 'w':
                        cvs_readonly = 0;
                        break;
                case 'x':
                        /*
                         * Kerberos encryption support, kept for compatibility
                         */
                        break;
                case 'z':
                        cvs_compress = strtonum(optarg, 0, 9, &errstr);
                        if (errstr != NULL)
                                fatal("cvs_compress: %s", errstr);
                        break;
                default:
                        usage();
                        /* NOTREACHED */
                }
        }

        ret = optind;
        optind = 1;
        optreset = 1;   /* for next call */

        return (ret);
}

/*
 * cvs_read_rcfile()
 *
 * Read the CVS `.cvsrc' file in the user's home directory.  If the file
 * exists, it should contain a list of arguments that should always be given
 * implicitly to the specified commands.
 */
static void
cvs_read_rcfile(void)
{
        char rcpath[PATH_MAX], *buf, *lbuf, *lp, *p;
        int cmd_parsed, cvs_parsed, i, linenum;
        size_t len, pos;
        struct cvs_cmd *tcmdp;
        FILE *fp;

        linenum = 0;

        i = snprintf(rcpath, PATH_MAX, "%s/%s", cvs_homedir, CVS_PATH_RC);
        if (i < 0 || i >= PATH_MAX) {
                cvs_log(LP_ERRNO, "%s", rcpath);
                return;
        }

        fp = fopen(rcpath, "r");
        if (fp == NULL) {
                if (errno != ENOENT)
                        cvs_log(LP_NOTICE, "failed to open `%s': %s", rcpath,
                            strerror(errno));
                return;
        }

        cmd_parsed = cvs_parsed = 0;
        lbuf = NULL;
        while ((buf = fgetln(fp, &len)) != NULL) {
                if (buf[len - 1] == '\n') {
                        buf[len - 1] = '\0';
                } else {
                        lbuf = xmalloc(len + 1);
                        memcpy(lbuf, buf, len);
                        lbuf[len] = '\0';
                        buf = lbuf;
                }

                linenum++;

                /* skip any whitespaces */
                p = buf;
                while (*p == ' ')
                        p++;

                /*
                 * Allow comments.
                 * GNU cvs stops parsing a line if it encounters a \t
                 * in front of a command, stick at this behaviour for
                 * compatibility.
                 */
                if (*p == '#' || *p == '\t')
                        continue;

                pos = strcspn(p, " \t");
                if (pos == strlen(p)) {
                        lp = NULL;
                } else {
                        lp = p + pos;
                        *lp = '\0';
                }

                if (strcmp(p, "cvs") == 0 && !cvs_parsed) {
                        /*
                         * Global default options.  In the case of cvs only,
                         * we keep the 'cvs' string as first argument because
                         * getopt() does not like starting at index 0 for
                         * argument processing.
                         */
                        if (lp != NULL) {
                                *lp = ' ';
                                cvs_defargs = xstrdup(p);
                        }
                        cvs_parsed = 1;
                } else {
                        tcmdp = cvs_findcmd(p);
                        if (tcmdp == NULL && verbosity == 2)
                                cvs_log(LP_NOTICE,
                                    "unknown command `%s' in `%s:%d'",
                                    p, rcpath, linenum);

                        if (tcmdp != cmdp || cmd_parsed)
                                continue;

                        if (lp != NULL) {
                                lp++;
                                cmdp->cmd_defargs = xstrdup(lp);
                        }
                        cmd_parsed = 1;
                }
        }
        free(lbuf);

        if (ferror(fp)) {
                cvs_log(LP_NOTICE, "failed to read line from `%s'", rcpath);
        }

        (void)fclose(fp);
}

/*
 * cvs_var_set()
 *
 * Set the value of the variable <var> to <val>.  If there is no such variable,
 * a new entry is created, otherwise the old value is overwritten.
 * Returns 0 on success, or -1 on failure.
 */
int
cvs_var_set(const char *var, const char *val)
{
        const char *cp;
        struct cvs_var *vp;

        if (var == NULL || *var == '\0') {
                cvs_log(LP_ERR, "no variable name");
                return (-1);
        }

        /* sanity check on the name */
        for (cp = var; *cp != '\0'; cp++)
                if (!isalnum((unsigned char)*cp) && (*cp != '_')) {
                        cvs_log(LP_ERR,
                            "variable name `%s' contains invalid characters",
                            var);
                        return (-1);
                }

        TAILQ_FOREACH(vp, &cvs_variables, cv_link)
                if (strcmp(vp->cv_name, var) == 0)
                        break;

        if (vp == NULL) {
                vp = xcalloc(1, sizeof(*vp));

                vp->cv_name = xstrdup(var);
                TAILQ_INSERT_TAIL(&cvs_variables, vp, cv_link);

        } else  /* free the previous value */
                free(vp->cv_val);

        vp->cv_val = xstrdup(val);

        return (0);
}

/*
 * cvs_var_unset()
 *
 * Remove any entry for the variable <var>.
 * Returns 0 on success, or -1 on failure.
 */
int
cvs_var_unset(const char *var)
{
        struct cvs_var *vp;

        TAILQ_FOREACH(vp, &cvs_variables, cv_link)
                if (strcmp(vp->cv_name, var) == 0) {
                        TAILQ_REMOVE(&cvs_variables, vp, cv_link);
                        free(vp->cv_name);
                        free(vp->cv_val);
                        free(vp);
                        return (0);
                }

        return (-1);
}

/*
 * cvs_var_get()
 *
 * Get the value associated with the variable <var>.  Returns a pointer to the
 * value string on success, or NULL if the variable does not exist.
 */

const char *
cvs_var_get(const char *var)
{
        struct cvs_var *vp;

        TAILQ_FOREACH(vp, &cvs_variables, cv_link)
                if (strcmp(vp->cv_name, var) == 0)
                        return (vp->cv_val);

        return (NULL);
}