/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <locale.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include "addrem.h"
#include "errmsg.h"
#include "plcysubr.h"

/* function prototypes */
static void     usage();
static int      unload_drv(char *, int, int);


/*
 * try to modunload driver.
 * return -1 on failure and 0 on success
 */
static int
unload_drv(char *driver_name, int force_flag, int verbose_flag)
{
        int modid;

        get_modid(driver_name, &modid);
        if (modid != -1) {
                if (modctl(MODUNLOAD, modid) < 0) {
                        (void) fprintf(stderr, gettext(ERR_MODUN), driver_name);
                        if (force_flag == 0) { /* no force flag */
                                if (verbose_flag) {
                                        (void) fprintf(stderr,
                                            gettext(NOUPDATE), driver_name);
                                }
                                /* clean up and exit. remove lock file */
                                err_exit();
                        }
                        (void) fprintf(stderr, gettext(FORCE_UPDATE),
                            driver_name);

                        return (-1);
                }
        }

        return (0);
}


static void
usage()
{
        (void) fprintf(stderr, gettext(UPD_DRV_USAGE));
        exit(1);
}


int
main(int argc, char *argv[])
{
        int     error, opt, major;
        int     cleanup_flag = 0;
        int     update_conf = 1;        /* reload driver.conf by default */
        int     verbose_flag = 0;       /* -v option */
        int     force_flag = 0;         /* -f option */
        int     a_flag = 0;             /* -a option */
        int     d_flag = 0;             /* -d option */
        int     i_flag = 0;             /* -i option */
        int     l_flag = 0;             /* -l option */
        int     m_flag = 0;             /* -m option */
        int     n_flag = 0;             /* -n option */
        char    *perms = NULL;
        char    *aliases = NULL;
        char    *basedir = NULL;
        char    *policy = NULL;
        char    *aliases2 = NULL;
        char    *priv = NULL;
        char    *driver_name;
        int     found;
        major_t major_num;
        int     rval;
        int     config_flags;

        (void) setlocale(LC_ALL, "");
#if     !defined(TEXT_DOMAIN)   /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif
        (void) textdomain(TEXT_DOMAIN);

        /*  must be run by root */
        if (getuid() != 0) {
                (void) fprintf(stderr, gettext(ERR_NOT_ROOT));
                exit(1);
        }

        while ((opt = getopt(argc, argv, "m:ni:b:p:adlfuvP:")) != EOF) {
                switch (opt) {
                case 'a':
                        a_flag++;
                        break;
                case 'b':
                        update_conf = 0;        /* don't update .conf file */
                        basedir = optarg;
                        break;
                case 'd':
                        d_flag++;
                        break;
                case 'f':
                        force_flag++;
                        break;
                case 'i':
                        i_flag++;
                        aliases = optarg;
                        if (check_space_within_quote(aliases) == ERROR) {
                                (void) fprintf(stderr, gettext(ERR_NO_SPACE),
                                    aliases);
                                exit(1);
                        }
                        break;
                case 'l':       /* private option */
                        l_flag++;
                        break;
                case 'm':
                        m_flag++;
                        perms = optarg;
                        break;
                case 'n':
                        n_flag++;
                        update_conf = 0;
                        break;
                case 'p':
                        policy = optarg;
                        break;
                case 'v':
                        verbose_flag++;
                        break;
                case 'P':
                        priv = optarg;
                        break;
                case '?' :
                default:
                        usage();
                }
        }

        /*
         * check for flags and extra args
         */
        if ((argv[optind] == NULL) || (optind + 1 != argc)) {
                usage();
        }

        /*
         * - cannot be adding and removing at the same time
         * - if -a or -d is specified, it's an error if none of
         *   -i/-m/-p/-P is specified.
         */
        if ((a_flag && d_flag) ||
            ((a_flag || d_flag) &&
            !m_flag && !i_flag && priv == NULL && policy == NULL)) {
                usage();
        }

        /*
         * - with -d option or -a option either -i 'identify_name',
         *      -m 'permission',  -p 'policy' or -P 'priv' should be specified
         */
        if (m_flag || i_flag || policy != NULL || priv != NULL) {
                if (!(a_flag || d_flag))
                        usage();
        }

        driver_name = argv[optind];

        /* set up update_drv filenames */
        if ((build_filenames(basedir)) == ERROR) {
                exit(1);
        }

        /* no lock is needed for listing minor perm entry */
        if (l_flag) {
                list_entry(minor_perm, driver_name, ":");

                return (NOERR);
        }

        /* must be only running version of add_drv/update_drv/rem_drv */
        enter_lock();

        if ((check_perms_aliases(m_flag, i_flag)) == ERROR) {
                err_exit();
        }

        /* update_drv doesn't modify /etc/name_to_major file */
        if ((check_name_to_major(R_OK)) == ERROR)
                err_exit();

        if ((n_flag == 0) &&
            (basedir == NULL || (strcmp(basedir, "/") == 0)) &&
            (priv != NULL) && check_priv_entry(priv, a_flag) != 0)
                err_exit();

        if (policy != NULL && (policy = check_plcy_entry(policy, driver_name,
            d_flag ? B_TRUE : B_FALSE)) == NULL)
                err_exit();

        /*
         * ADD: -a option
         * i_flag: update /etc/driver_aliases
         * m_flag: update /etc/minor_perm
         * -p: update /etc/security/device_policy
         * -P: update /etc/security/extra_privs
         * if force_flag is specified continue w/ the next operation
         */
        if (a_flag) {
                if (m_flag) {
                        /* check if the permissions are valid */
                        if ((error = check_perm_opts(perms)) == ERROR) {
                                if (force_flag == 0) { /* no force flag */
                                        exit_unlock();
                                        return (error);
                                }
                        }

                        /*
                         * update the file, if and only if
                         * we didn't run into error earlier.
                         */
                        if ((error != ERROR) &&
                            (error = update_minor_entry(driver_name, perms))) {
                                if (force_flag == 0) { /* no force flag */
                                        exit_unlock();
                                        return (error);
                                }
                        }
                        cleanup_flag |= CLEAN_NAM_MAJ;

                        /*
                         * Notify running system of minor perm change
                         */
                        if ((n_flag == 0) &&
                            (basedir == NULL || (strcmp(basedir, "/") == 0))) {
                                rval = devfs_add_minor_perm(driver_name,
                                    log_minorperm_error);
                                if (rval) {
                                        (void) fprintf(stderr,
                                            gettext(ERR_UPDATE_PERM),
                                            driver_name);
                                }
                        }
                }

                if (priv != NULL) {
                        (void) append_to_file(driver_name, priv, extra_privs,
                            ',', ":", 0);
                        cleanup_flag |= CLEAN_DRV_PRIV;
                }

                if (policy != NULL) {
                        if ((error = update_device_policy(device_policy,
                            policy, B_TRUE)) != 0) {
                                exit_unlock();
                                return (error);
                        }
                        cleanup_flag |= CLEAN_DEV_POLICY;
                }

                if (i_flag) {
                        found = get_major_no(driver_name, name_to_major);
                        if (found == ERROR) {
                                (void) fprintf(stderr, gettext(ERR_MAX_MAJOR),
                                    name_to_major);
                                err_exit();
                        }

                        if (found == UNIQUE) {
                                (void) fprintf(stderr,
                                    gettext(ERR_NOT_INSTALLED), driver_name);
                                err_exit();
                        }

                        major_num = (major_t)found;

                        /*
                         * To ease the nuisance of using update_drv
                         * in packaging scripts, do not require that
                         * existing driver aliases be trimmed from
                         * the command line.  If an invocation asks
                         * to add an alias and it's already there,
                         * drive on.  We implement this by removing
                         * duplicates now and add the remainder.
                         */
                        error = trim_duplicate_aliases(driver_name,
                            aliases, &aliases2);
                        if (error == ERROR) {
                                exit_unlock();
                                return (error);
                        }

                        /*
                         * if the list of aliases to be added is
                         * now empty, we're done.
                         */
                        if (aliases2 == NULL)
                                goto done;

                        /*
                         * unless force_flag is specified check that
                         * path-oriented aliases we are adding exist
                         */
                        if ((force_flag == 0) && ((error =
                            aliases_paths_exist(aliases2)) == ERROR)) {
                                exit_unlock();
                                return (error);
                        }

                        /* update the file */
                        if ((error = update_driver_aliases(driver_name,
                            aliases2)) == ERROR) {
                                exit_unlock();
                                return (error);
                        }


                        /* optionally update the running system - not -b */
                        if (update_conf) {
                                /* paranoia - if we crash whilst configuring */
                                sync();
                                config_flags = (verbose_flag) ?
                                    CONFIG_DRV_VERBOSE : 0;
                                cleanup_flag |= CLEAN_DRV_ALIAS;
                                if (config_driver(driver_name, major_num,
                                    aliases2, NULL, cleanup_flag,
                                    config_flags) == ERROR) {
                                        err_exit();
                                }
                        }

                }

done:
                if (update_conf && (i_flag || policy != NULL)) {
                        /* load the driver */
                        load_driver(driver_name, verbose_flag);
                }

                exit_unlock();

                return (0);
        }


        /*
         * DELETE: -d option
         * i_flag: update /etc/driver_aliases
         * m_flag: update /etc/minor_perm
         * -p: update /etc/security/device_policy
         * -P: update /etc/security/extra_privs
         * if force_flag is specified continue w/ the next operation
         */
        if (d_flag) {
                int err = NOERR;

                if (m_flag) {
                        /*
                         * On a running system, we first need to
                         * remove devfs's idea of the minor perms.
                         * We don't have any ability to do this singly
                         * at this point.
                         */
                        if ((n_flag == 0) &&
                            (basedir == NULL || (strcmp(basedir, "/") == 0))) {
                                rval = devfs_rm_minor_perm(driver_name,
                                    log_minorperm_error);
                                if (rval) {
                                        (void) fprintf(stderr,
                                            gettext(ERR_UPDATE_PERM),
                                            driver_name);
                                }
                        }

                        if ((error = delete_entry(minor_perm,
                            driver_name, ":", perms)) != NOERR) {
                                (void) fprintf(stderr, gettext(ERR_NO_ENTRY),
                                    driver_name, minor_perm);
                                err = error;
                        }
                        /*
                         * Notify running system of new minor perm state
                         */
                        if ((n_flag == 0) &&
                            (basedir == NULL || (strcmp(basedir, "/") == 0))) {
                                rval = devfs_add_minor_perm(driver_name,
                                    log_minorperm_error);
                                if (rval) {
                                        (void) fprintf(stderr,
                                            gettext(ERR_UPDATE_PERM),
                                            driver_name);
                                }
                        }
                }

                if (i_flag) {
                        found = get_major_no(driver_name, name_to_major);
                        if (found == ERROR) {
                                (void) fprintf(stderr, gettext(ERR_MAX_MAJOR),
                                    name_to_major);
                                err_exit();
                        }

                        if (found == UNIQUE) {
                                (void) fprintf(stderr,
                                    gettext(ERR_NOT_INSTALLED), driver_name);
                                err_exit();
                        }

                        major_num = (major_t)found;

                        /*
                         * verify that the aliases to be deleted exist
                         * before removal.  With -f, failing to
                         * remove an alias is not an error so we
                         * can continue on to update the kernel.
                         */
                        error = NOERR;
                        rval = aliases_exist(aliases);
                        if (rval == ERROR && (force_flag == 0)) {
                                (void) fprintf(stderr,
                                    gettext(ERR_ALIAS_NOT_BOUND),
                                    driver_name);
                                if (err != NOERR)
                                        err = rval;
                        }
                        if (rval == NOERR)
                                error = delete_entry(driver_aliases,
                                    driver_name, ":", aliases);
                        if (error != NOERR && (force_flag == 0)) {
                                (void) fprintf(stderr, gettext(ERR_NO_ENTRY),
                                    driver_name, driver_aliases);
                                if (err != NOERR)
                                        err = error;
                        }

                        /*
                         * optionally update the running system - not -b.
                         * Unless -f is specified, error if one or more
                         * devices remain bound to the alias.
                         */
                        if (err == NOERR && update_conf) {
                                /* paranoia - if we crash whilst configuring */
                                sync();

                                config_flags = 0;
                                if (verbose_flag)
                                        config_flags |= CONFIG_DRV_VERBOSE;
                                if (force_flag)
                                        config_flags |= CONFIG_DRV_FORCE;
                                error = unconfig_driver(driver_name, major_num,
                                    aliases, config_flags);
                                if (error == ERROR && force_flag == 0) {
                                        (void) fprintf(stderr,
                                            gettext(ERR_DEV_IN_USE),
                                            driver_name);
                                        if (err != NOERR)
                                                err = error;
                                }
                        }
                }

                if (priv != NULL) {
                        if ((error = delete_entry(extra_privs, driver_name, ":",
                            priv)) != NOERR) {
                                (void) fprintf(stderr, gettext(ERR_NO_ENTRY),
                                    driver_name, extra_privs);
                                if (err != NOERR)
                                        err = error;
                        }
                }

                if (policy != NULL) {
                        if ((error = delete_plcy_entry(device_policy,
                            policy)) != NOERR) {
                                (void) fprintf(stderr, gettext(ERR_NO_ENTRY),
                                    driver_name, device_policy);
                                if (err != NOERR)
                                        err = error;
                        }
                }

                if (err == NOERR && update_conf) {
                        if (i_flag || m_flag) {
                                /* try to unload the driver */
                                (void) unload_drv(driver_name,
                                    force_flag, verbose_flag);
                        }
                        /* reload the policy */
                        if (policy != NULL)
                                load_driver(driver_name, verbose_flag);
                }
                exit_unlock();

                return (err);
        }

        /* driver name must exist (for update_conf stuff) */
        major = get_major_no(driver_name, name_to_major);
        if (major == ERROR) {
                err_exit();
        }

        /*
         * Update driver.conf file:
         *      First try to unload driver module. If it fails, there may
         *      be attached devices using the old driver.conf properties,
         *      so we cannot safely update driver.conf
         *
         *      The user may specify -f to force a driver.conf update.
         *      In this case, we will update driver.conf cache. All attached
         *      devices still reference old driver.conf properties, including
         *      driver global properties. Devices attached in the future will
         *      referent properties in the updated driver.conf file.
         */
        if (update_conf) {
                (void) unload_drv(driver_name, force_flag, verbose_flag);

                if ((modctl(MODUNLOADDRVCONF, major) != 0) ||
                    (modctl(MODLOADDRVCONF, major, 0) != 0)) {
                        (void) fprintf(stderr, gettext(ERR_DRVCONF),
                            driver_name);
                        err_exit();
                }

                if (verbose_flag) {
                        (void) fprintf(stderr, gettext(DRVCONF_UPDATED),
                            driver_name);
                }
                load_driver(driver_name, verbose_flag);
        }

        exit_unlock();

        return (NOERR);
}