svr4pkg/pkginstall/quit.c

/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */


#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <sys/utsname.h>
#include <limits.h>
#include <stdlib.h>
#include <unistd.h>
#include <pkgdev.h>
#include <pkglocs.h>
#include <locale.h>
#include <libintl.h>
#include <errno.h>
#include <pkglib.h>
#include "install.h"
#include "dryrun.h"
#include "libadm.h"
#include "libinst.h"
#include "pkginstall.h"
#include "messages.h"

/* main.c */
extern char     *pkgdrtarg;
extern struct cfextra   **extlist;

extern struct   admin adm;
extern struct   pkgdev pkgdev;  /* holds info about the installation device */

extern int  dparts;
extern int  dreboot;    /* != 0 if reboot required after installation */
extern int  failflag;   /* != 0 if fatal error has occurred (1) */
extern int  ireboot;    /* != 0 if immediate reboot required */
extern int  warnflag;   /* != 0 if non-fatal error has occurred (2) */

extern char tmpdir[];
extern char pkgloc[];
extern char pkgloc_sav[];
extern char *msgtext;
extern char *pkginst;
extern char *pkgname;

/*
 * exported functions
 */

void        quit(int retcode);
void        quitSetZoneName(char *a_zoneName);
sighdlrFunc_t   *quitGetTrapHandler(void);

/*
 * forward declarations
 */

static void     trap(int signo);
static void     mailmsg(int retcode);
static void     quitmsg(int retcode);

static boolean_t    silentExit = B_FALSE;
static boolean_t    pkgaskFlag = B_FALSE;
static boolean_t    installStarted = B_FALSE;
static boolean_t    updatingExistingPackage = B_FALSE;

static char     *dstreamTempDir = (char *)NULL;
static char     *zoneName = (char *)NULL;
static int      includeZonename = 0;
static int      trapEntered = 0;

/*
 * *****************************************************************************
 * global external (public) functions
 * *****************************************************************************
 */

/*
 * Name:    quitGetTrapHandler
 * Description: return address of this modules "signal trap" handler
 * Arguments:   void
 * Returns: sighdlrFunc_t
 *          The address of the trap handler that can be passed to
 *          the signal() type system calls
 */

sighdlrFunc_t *
quitGetTrapHandler(void)
{
    return (&trap);
}

/*
 * Name:    quitSetZoneName
 * Description: set the zone name the program is running in
 * Arguments:   a_zoneName - pointer to string representing the name of the zone
 *          that the program is running in
 * Returns: void
 */

void
quitSetZoneName(char *a_zoneName)
{
    zoneName = a_zoneName;
    if ((zoneName == (char *)NULL || *zoneName == '\0')) {
        includeZonename = 0;
    } else {
        includeZonename = 1;
    }
}

/*
 * Name:    quitSetDstreamTmpdir
 * Description: set the name of a temporary directory that contains package
 *      streams to be removed when quit() is called
 * Arguments:   a_dstreamTempDir - pointer to string representing the path
 *          to the temporary directory to remove when quit()
 *          is called
 * Returns: void
 */

void
quitSetDstreamTmpdir(char *a_dstreamTempDir)
{
    dstreamTempDir = a_dstreamTempDir;
}

/*
 * Name:    quitSetUpdatingExisting
 * Description: set the "updating existing" flag - used in conjunction
 *      with the "install started" flag to determine the type
 *      of cleanup to be done when quit() is called
 * Arguments:   a_updatingExistingPackage - indicates whether or not existing
 *          packages are being updated (B_TRUE) or new packages
 *          are being installed (B_FALSE)
 * Returns: void
 */

void
quitSetUpdatingExisting(boolean_t a_updatingExistingPackage)
{
    updatingExistingPackage = a_updatingExistingPackage;
}

/*
 * Name:    quitSetInstallStarted
 * Description: set the "install started" flag - used in conjunction
 *      with the "updating existing" flag to determine the type
 *      of cleanup to be done when quit() is called, and the
 *      type of message to be output for the "reason" why quit()
 *      was called
 * Arguments:   a_installStarted - indicates whether or not installation
 *          has started
 * Returns: void
 */

void
quitSetInstallStarted(boolean_t a_installStarted)
{
    installStarted = a_installStarted;
}

/*
 * Name:    quitSetPkgask
 * Description: set the "pkgask is being run" flag - used to determine
 *      the type of message to be output for the "reason" why
 *      quit() was called
 * Arguments:   a_pkgaskflag - indicates whether or not pkgask is being run
 * Returns: void
 */

void
quitSetPkgask(boolean_t a_pkgaskFlag)
{
    pkgaskFlag = a_pkgaskFlag;
}

/*
 * Name:    quitSetSilentExit
 * Description: set the "silent exit" flag - if silent exit is TRUE, then
 *      no messages are output by quit() when it is called
 * Arguments:   a_silentExit - indicates whether or not silent exit is set
 * Returns: void
 */

void
quitSetSilentExit(boolean_t a_silentExit)
{
    silentExit = a_silentExit;
}

/*
 * Name:    quit
 * Description: cleanup and exit
 * Arguments:   a_retcode - the code to use to determine final exit status;
 *          if this is NOT "99" and if a "ckreturnFunc" is
 *          set, then that function is called with a_retcode
 *          to set the final exit status.
 *      Valid values are:
 *      0 - success
 *      1 - package operation failed (fatal error)
 *      2 - non-fatal error (warning)
 *      3 - user selected quit (operation interrupted)
 *      4 - admin settings prevented operation
 *      5 - interaction required and -n (non-interactive) specified
 *      "10" is added to indicate "immediate reboot required"
 *      "20" is be added to indicate "reboot after install required"
 *      99 - do not interpret the code - just exit "99"
 * Returns: <<this function does not return - calls exit()>>
 */

void
quit(int retcode)
{
    /* disable interrupts */

    (void) signal(SIGINT, SIG_IGN);
    (void) signal(SIGHUP, SIG_IGN);

    /* process return code if not quit(99) */

    if (retcode != 99) {
        if ((retcode % 10) == 0) {
            if (failflag) {
                retcode += 1;
            } else if (warnflag) {
                retcode += 2;
            }
        }

        if (ireboot) {
            retcode = (retcode % 10) + 20;
        }
        if (dreboot) {
            retcode = (retcode % 10) + 10;
        }
    }

    /* if set remove dstream temporary directory */

    if (dstreamTempDir != (char *)NULL) {
        echoDebug(DBG_REMOVING_DSTREAM_TMPDIR, dstreamTempDir);
        (void) rrmdir(dstreamTempDir);
        dstreamTempDir = (char *)NULL;
    }

    /* If we're in dryrun mode, write out the dryrun file(s). */
    if (in_dryrun_mode()) {
        char exit_msg[200];
        set_dr_info(EXITCODE, retcode);
        if (failflag || warnflag) {
            set_dr_exitmsg(msgtext);
        } else {
            /* LINTED variable format specified */
            (void) snprintf(exit_msg, sizeof (exit_msg),
                qreason(1, retcode, installStarted,
                    includeZonename),
                    (pkginst ? pkginst : "unknown"),
                    zoneName);
            set_dr_exitmsg(exit_msg);
        }

        write_dryrun_file(extlist);
        ptext(stderr, MSG_DRYRUN_DONE);
        ptext(stderr, MSG_NOCHANGE);

        if (tmpdir[0] != NULL)
            (void) rrmdir(tmpdir);

    } else {
        /* fix bug #1082589 that deletes root file */
        if (tmpdir[0] != NULL) {
            (void) rrmdir(tmpdir);
        }

        /* send mail to appropriate user list */
        mailmsg(retcode);

        /* display message about this installation */
        quitmsg(retcode);
    }

    /*
     * In the event that this quit() was called prior to completion of
     * the task, do an unlockinst() just in case.
     */
    unlockinst();

    /* Unmount anything that's our responsibility. */
    (void) unmount_client();

    /*
     * No need to umount device since calling process
     * was responsible for original mount
     */

    if (!updatingExistingPackage) {
        if (!installStarted && pkgloc[0]) {
            /*
             * install not yet started; if package install
             * location is defined, remove the package.
             */
            echoDebug(DBG_QUIT_REMOVING_PKGDIR, pkgloc);

            (void) chdir("/");
            if (pkgloc[0]) {
                (void) rrmdir(pkgloc);
            }
        }
    } else {
        if (!installStarted) {
            /*
             * If we haven't started, but have already done
             * the <PKGINST>/install directory rename, then
             * remove the new <PKGINST>/install directory
             * and rename <PKGINST>/install.save back to
             * <PKGINST>/install.
             */
            if (pkgloc_sav[0] && !access(pkgloc_sav, F_OK)) {
                if (pkgloc[0] && !access(pkgloc, F_OK))
                    (void) rrmdir(pkgloc);
                if (rename(pkgloc_sav, pkgloc) == -1) {
                    progerr(ERR_PACKAGEBINREN,
                        pkgloc_sav, pkgloc);
                }
            }
        } else {
            if (pkgloc_sav[0] && !access(pkgloc_sav, F_OK)) {
                echoDebug(DBG_QUIT_REMOVING_PKGSAV, pkgloc_sav);
                (void) rrmdir(pkgloc_sav);
            }
        }
    }

    /*
     * pkginst can be null if an administration setting doesn't all
     * the package to be installed. Make sure pkginst exeists before
     * updating the DB
     */

    if (dparts > 0)
        ds_skiptoend(pkgdev.cdevice);
    (void) ds_close(1);

    /* Free the filesystem table. */
    fs_tab_free();

    /* Free the package information lists. */
    pinfo_free();

    /* Free all stragglers. */
    bl_free(BL_ALL);
    (void) pathdup(NULL);

    /* Free regfiles. */
    regfiles_free();

    /* final exit debugging message */

    echoDebug(DBG_EXIT_WITH_CODE, retcode);

    exit(retcode);
    /*NOTREACHED*/
}

/*
 * *****************************************************************************
 * static internal (private) functions
 * *****************************************************************************
 */

static void
quitmsg(int retcode)
{
    if (silentExit == B_TRUE) {
        return;
    }

    (void) putc('\n', stderr);
    if (pkgaskFlag) {
        ptext(stderr, qreason(0, retcode, installStarted,
            includeZonename), zoneName);
    } else if (pkginst) {
        ptext(stderr, qreason(1, retcode, installStarted,
            includeZonename), pkginst, zoneName);
    }

    if (retcode && !installStarted) {
        ptext(stderr, MSG_NOCHANGE);
    }
}

static void
mailmsg(int retcode)
{
    struct utsname utsbuf;
    FILE    *pp;
    char    *cmd;
    size_t  len;

    if (silentExit == B_TRUE) {
        return;
    }

    if (!installStarted || pkgaskFlag || (adm.mail == NULL)) {
        return;
    }

    len = strlen(adm.mail) + sizeof (MAILCMD) + 2;
    cmd = calloc(len, sizeof (char));
    if (cmd == NULL) {
        logerr(WRN_NOMAIL);
        return;
    }

    (void) snprintf(cmd, len, "%s %s", MAILCMD, adm.mail);
    if ((pp = popen(cmd, "w")) == NULL) {
        logerr(WRN_NOMAIL);
        return;
    }

    if (msgtext)
        ptext(pp, msgtext);

    (void) strcpy(utsbuf.nodename, MSG_NODENAME);
    (void) uname(&utsbuf);

    ptext(pp, qreason(2, retcode, installStarted, includeZonename),
        pkgname, utsbuf.nodename, pkginst, zoneName);

    if (pclose(pp)) {
        logerr(WRN_FLMAIL);
    }
}

/*
 * Name:    trap
 * Description: signal handler connected via quitGetTrapHandler()
 * Arguments:   signo - [RO, *RO] - (int)
 *          Integer representing the signal that caused the trap
 *          to this function to occur
 * Returns: << NONE >>
 * NOTE:    This function exits the program after doing mandatory cleanup.
 * NOTE:    Even though quit() should NOT return, there is a call to _exit()
 *      put after each call to quit() just in case quit() ever returned
 *      by mistake.
 */

static void
trap(int signo)
{
    /* prevent reentrance */

    if (trapEntered++ != 0) {
        return;
    }

    if ((signo == SIGINT) || (signo == SIGHUP)) {
        quit(3);
        _exit(3);
    }
    quit(1);
    _exit(1);
}