/*
 * 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.
 *
 * Copyright 2023 OmniOS Community Edition (OmniOSce) Association.
 */

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

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*      Copyright (c) 1987, 1988 Microsoft Corporation  */
/*        All Rights Reserved   */

/*
 * For a complete reference to login(1), see the manual page.  However,
 * login has accreted some intentionally undocumented options, which are
 * explained here:
 *
 * -a: This legacy flag appears to be unused.
 *
 * -f <username>: This flag was introduced by PSARC 1995/039 in support
 *    of Kerberos.  But it's not used by Sun's Kerberos implementation.
 *    It is however employed by zlogin(1), since it allows one to tell
 *    login: "This user is authenticated."  In the case of zlogin that's
 *    true because the zone always trusts the global zone.
 *
 * -z <zonename>: This flag is passed to login when zlogin(1) executes a
 *    zone login.  This tells login(1) to skip it's normal CONSOLE check
 *    (i.e. that the root login must be on /dev/console) and tells us the
 *    name of the zone from which the login is occurring.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <unistd.h>     /* For logfile locking */
#include <signal.h>
#include <stdio.h>
#include <sys/stat.h>
#include <string.h>
#include <deflt.h>
#include <grp.h>
#include <fcntl.h>
#include <lastlog.h>
#include <termio.h>
#include <utmpx.h>
#include <stdlib.h>
#include <wait.h>
#include <errno.h>
#include <ctype.h>
#include <syslog.h>
#include <ulimit.h>
#include <libgen.h>
#include <pwd.h>
#include <security/pam_appl.h>
#include <strings.h>
#include <libdevinfo.h>
#include <zone.h>
#include "login_audit.h"

#include <krb5_repository.h>
/*
 *
 *          *** Defines, Macros, and String Constants  ***
 *
 *
 */

#define ISSUEFILE "/etc/issue"  /* file to print before prompt */
#define NOLOGIN "/etc/nologin"  /* file to lock users out during shutdown */

/*
 * These need to be defined for UTMPX management.
 * If we add in the utility functions later, we
 * can remove them.
 */
#define __UPDATE_ENTRY  1
#define __LOGIN         2

/*
 * Intervals to sleep after failed login
 */
#ifndef SLEEPTIME
#define SLEEPTIME 4     /* sleeptime before login incorrect msg */
#endif
static int      Sleeptime = SLEEPTIME;

/*
 * seconds login disabled after allowable number of unsuccessful attempts
 */
#ifndef DISABLETIME
#define DISABLETIME     20
#endif
static int      Disabletime = DISABLETIME;

#define MAXTRYS         5

static int      retry = MAXTRYS;

/*
 * Login logging support
 */
#define LOGINLOG        "/var/adm/loginlog"     /* login log file */
#define LNAME_SIZE      20      /* size of logged logname */
#define TTYN_SIZE       15      /* size of logged tty name */
#define TIME_SIZE       30      /* size of logged time string */
#define ENT_SIZE        (LNAME_SIZE + TTYN_SIZE + TIME_SIZE + 3)
#define L_WAITTIME      5       /* waittime for log file to unlock */
#define LOGTRYS         10      /* depth of 'try' logging */

/*
 * String manipulation macros: SCPYN, SCPYL, EQN and ENVSTRNCAT
 * SCPYL is the safer version of SCPYN
 */
#define SCPYL(a, b)     (void) strlcpy(a, b, sizeof (a))
#define SCPYN(a, b)     (void) strncpy(a, b, sizeof (a))
#define EQN(a, b)       (strncmp(a, b, sizeof (a)-1) == 0)
#define ENVSTRNCAT(to, from) {int deflen; deflen = strlen(to); \
        (void) strncpy((to)+ deflen, (from), sizeof (to) - (1 + deflen)); }

/*
 * Other macros
 */
#define NMAX    sizeof (((struct utmpx *)0)->ut_name)
#define HMAX    sizeof (((struct utmpx *)0)->ut_host)
#define min(a, b)       (((a) < (b)) ? (a) : (b))

/*
 * Various useful files and string constants
 */
#define SHELL           "/usr/bin/sh"
#define SHELL2          "/sbin/sh"
#define SUBLOGIN        "<!sublogin>"
#define LASTLOG         "/var/adm/lastlog"
#define PROG_NAME       "login"
#define HUSHLOGIN       ".hushlogin"

/*
 * Array and Buffer sizes
 */
#define PBUFSIZE 8      /* max significant characters in a password */
#define MAXARGS 63      /* change value below if changing this */
#define MAXARGSWIDTH 2  /* log10(MAXARGS) */
#define MAXENV 1024
#define MAXLINE 2048

/*
 * Miscellaneous constants
 */
#define ROOTUID         0
#define ERROR           1
#define OK              0
#define LOG_ERROR       1
#define DONT_LOG_ERROR  0
#define TRUE            1
#define FALSE           0

/*
 * Counters for counting the number of failed login attempts
 */
static int trys = 0;
static int count = 1;

/*
 * error value for login_exit() audit output (0 == no audit record)
 */
static int      audit_error = 0;

/*
 * Externs a plenty
 */
extern  int     getsecretkey();

/*
 * The current user name
 */
static  char    user_name[NMAX];
static  char    minusnam[16] = "-";

/*
 * login_pid, used to find utmpx entry to update.
 */
static pid_t    login_pid;

/*
 * locale environments to be passed to shells.
 */
static char *localeenv[] = {
        "LANG",
        "LC_CTYPE", "LC_NUMERIC", "LC_TIME", "LC_COLLATE",
        "LC_MONETARY", "LC_MESSAGES", "LC_ALL", 0};
static int locale_envmatch(char *, char *);

/*
 * Environment variable support
 */
static  char    shell[256] = { "SHELL=" };
static  char    home[MAXPATHLEN] = { "HOME=" };
static  char    term[64] = { "TERM=" };
static  char    logname[30] = { "LOGNAME=" };
static  char    timez[100] = { "TZ=" };
static  char    hertz[10] = { "HZ=" };
static  char    path[MAXPATHLEN] = { "PATH=" };
static  char    *newenv[10+MAXARGS] =
        {home, path, logname, hertz, term, 0, 0};
static  char    **envinit = newenv;
static  int     basicenv;
static  char    *zero = (char *)0;
static  char    **envp;
#ifndef NO_MAIL
static  char    mail[30] = { "MAIL=/var/mail/" };
#endif
extern char **environ;
static  char inputline[MAXLINE];

#define MAX_ID_LEN 256
#define MAX_REPOSITORY_LEN 256
#define MAX_PAMSERVICE_LEN 256

static char identity[MAX_ID_LEN];
static char repository[MAX_REPOSITORY_LEN];
static char progname[MAX_PAMSERVICE_LEN];


/*
 * Strings used to prompt the user.
 */
static  char    loginmsg[] = "login: ";
static  char    passwdmsg[] = "Password:";
static  char    incorrectmsg[] = "Login incorrect\n";

/*
 * Password file support
 */
static  struct  passwd *pwd = NULL;
static  char    remote_host[HMAX];
static  char    zone_name[ZONENAME_MAX];

/*
 * Illegal passwd entries.
 */
static  struct  passwd nouser = { "", "no:password", (uid_t)-1 };

/*
 * Log file support
 */
static  char    *log_entry[LOGTRYS];
static  int     writelog = 0;
static  int     lastlogok = 0;
static  struct lastlog ll;
static  int     dosyslog = 0;
static  int     flogin = MAXTRYS;       /* flag for SYSLOG_FAILED_LOGINS */

/*
 * Default file toggles
 */
static  char    *Pndefault      = "/etc/default/login";
static  char    *Altshell       = NULL;
static  char    *Console        = NULL;
static  int     Passreqflag     = 0;

#define DEFUMASK        022
static  mode_t  Umask           = DEFUMASK;
static  char    *Def_tz         = NULL;
static  char    *tmp_tz         = NULL;
static  char    *Def_hertz      = NULL;
#define SET_FSIZ        2                       /* ulimit() command arg */
static  long    Def_ulimit      = 0;
#define MAX_TIMEOUT     (15 * 60)
#define DEF_TIMEOUT     (5 * 60)
static  unsigned Def_timeout    = DEF_TIMEOUT;
static  char    *Def_path       = NULL;
static  char    *Def_supath     = NULL;
#define DEF_PATH        "/usr/bin:"     /* same as PATH */
#define DEF_SUPATH      "/usr/sbin:/usr/bin" /* same as ROOTPATH */

/*
 * Defaults for updating expired passwords
 */
#define DEF_ATTEMPTS    3

/*
 * ttyprompt will point to the environment variable TTYPROMPT.
 * TTYPROMPT is set by ttymon if ttymon already wrote out the prompt.
 */
static  char    *ttyprompt = NULL;
static  char    *ttyn = NULL;

/*
 * Pass inherited environment.  Used by telnetd in support of the telnet
 * ENVIRON option.
 */
static  boolean_t pflag = B_FALSE;
static  boolean_t uflag = B_FALSE;
static  boolean_t Rflag = B_FALSE;
static  boolean_t sflag = B_FALSE;
static  boolean_t Uflag = B_FALSE;
static  boolean_t tflag = B_FALSE;
static  boolean_t hflag = B_FALSE;
static  boolean_t rflag = B_FALSE;
static  boolean_t zflag = B_FALSE;

/*
 * Remote login support
 */
static  char    rusername[NMAX+1], lusername[NMAX+1];
static  char    terminal[MAXPATHLEN];

/*
 * Pre-authentication flag support
 */
static  int     fflag;

static char ** getargs(char *);

static int login_conv(int, const struct pam_message **,
    struct pam_response **, void *);

static struct pam_conv pam_conv = {login_conv, NULL};
static pam_handle_t *pamh;      /* Authentication handle */

/*
 * Function declarations
 */
static  void    turn_on_logging(void);
static  void    defaults(void);
static  void    usage(void);
static  void    process_rlogin(void);
static  void    login_authenticate();
static  void    setup_credentials(void);
static  void    adjust_nice(void);
static  void    update_utmpx_entry(int);
static  void    establish_user_environment(char **);
static  void    print_banner(void);
static  void    display_last_login_time(void);
static  void    exec_the_shell(void);
static  int     process_chroot_logins(void);
static  void    chdir_to_dir_user(void);
static  void    check_log(void);
static  void    validate_account(void);
static  void    doremoteterm(char *);
static  int     get_options(int, char **);
static  void    getstr(char *, int, char *);
static  int     legalenvvar(char *);
static  void    check_for_console(void);
static  void    check_for_dueling_unix(char *);
static  void    get_user_name(void);
static  uint_t  get_audit_id(void);
static  void    login_exit(int)__NORETURN;
static  int     logins_disabled(char *);
static  void    log_bad_attempts(void);
static  int     is_number(char *);

/*
 *                      *** main ***
 *
 *      The primary flow of control is directed in this routine.
 *      Control moves in line from top to bottom calling subfunctions
 *      which perform the bulk of the work.  Many of these calls exit
 *      when a fatal error is encountered and do not return to main.
 *
 *
 */

int
main(int argc, char *argv[], char **renvp)
{
        int sublogin;
        int pam_rc;

        login_pid = getpid();

        /*
         * Set up Defaults and flags
         */
        defaults();
        SCPYL(progname, PROG_NAME);

        /*
         * Set up default umask
         */
        if (Umask > ((mode_t)0777))
                Umask = DEFUMASK;
        (void) umask(Umask);

        /*
         * Set up default timeouts and delays
         */
        if (Def_timeout > MAX_TIMEOUT)
                Def_timeout = MAX_TIMEOUT;
        if (Sleeptime < 0 || Sleeptime > 5)
                Sleeptime = SLEEPTIME;

        (void) alarm(Def_timeout);

        /*
         * Ignore SIGQUIT and SIGINT and set nice to 0
         */
        (void) signal(SIGQUIT, SIG_IGN);
        (void) signal(SIGINT, SIG_IGN);
        (void) nice(0);

        /*
         * Set flag to disable the pid check if you find that you are
         * a subsystem login.
         */
        sublogin = 0;
        if (*renvp && strcmp(*renvp, SUBLOGIN) == 0)
                sublogin = 1;

        /*
         * Parse Arguments
         */
        if (get_options(argc, argv) == -1) {
                usage();
                audit_error = ADT_FAIL_VALUE_BAD_CMD;
                login_exit(1);
        }

        /*
         * if devicename is not passed as argument, call ttyname(0)
         */
        if (ttyn == NULL) {
                ttyn = ttyname(0);
                if (ttyn == NULL)
                        ttyn = "/dev/???";
        }

        /*
         * Call pam_start to initiate a PAM authentication operation
         */

        if ((pam_rc = pam_start(progname, user_name, &pam_conv, &pamh))
            != PAM_SUCCESS) {
                audit_error = ADT_FAIL_PAM + pam_rc;
                login_exit(1);
        }
        if ((pam_rc = pam_set_item(pamh, PAM_TTY, ttyn)) != PAM_SUCCESS) {
                audit_error = ADT_FAIL_PAM + pam_rc;
                login_exit(1);
        }
        if ((pam_rc = pam_set_item(pamh, PAM_RHOST, remote_host)) !=
            PAM_SUCCESS) {
                audit_error = ADT_FAIL_PAM + pam_rc;
                login_exit(1);
        }

        /*
         * We currently only support special handling of the KRB5 PAM repository
         */
        if ((Rflag && strlen(repository)) &&
            strcmp(repository, KRB5_REPOSITORY_NAME) == 0 &&
            (uflag && strlen(identity))) {
                krb5_repository_data_t krb5_data;
                pam_repository_t pam_rep_data;

                krb5_data.principal = identity;
                krb5_data.flags = SUNW_PAM_KRB5_ALREADY_AUTHENTICATED;

                pam_rep_data.type = repository;
                pam_rep_data.scope = (void *)&krb5_data;
                pam_rep_data.scope_len = sizeof (krb5_data);

                (void) pam_set_item(pamh, PAM_REPOSITORY,
                    (void *)&pam_rep_data);
        }

        /*
         * Open the log file which contains a record of successful and failed
         * login attempts
         */
        turn_on_logging();

        /*
         * say "hi" to syslogd ..
         */
        openlog("login", 0, LOG_AUTH);

        /*
         * Do special processing for -r (rlogin) flag
         */
        if (rflag)
                process_rlogin();

        /*
         * validate user
         */
        /* we are already authenticated. fill in what we must, then continue */
        if (fflag) {
                if ((pwd = getpwnam(user_name)) == NULL) {
                        audit_error = ADT_FAIL_VALUE_USERNAME;

                        log_bad_attempts();
                        (void) printf("Login failed: unknown user '%s'.\n",
                            user_name);
                        login_exit(1);
                }
        } else {
                /*
                 * Perform the primary login authentication activity.
                 */
                login_authenticate();
        }

        /* change root login, then we exec another login and try again */
        if (process_chroot_logins() != OK)
                login_exit(1);

        /*
         * If root login and not on system console then call exit(2)
         */
        check_for_console();

        /*
         * Check to see if a shutdown is in progress, if it is and
         * we are not root then throw the user off the system
         */
        if (logins_disabled(user_name) == TRUE) {
                audit_error = ADT_FAIL_VALUE_LOGIN_DISABLED;
                login_exit(1);
        }

        if (pwd->pw_uid == 0) {
                if (Def_supath != NULL)
                        Def_path = Def_supath;
                else
                        Def_path = DEF_SUPATH;
        }

        /*
         * Check account expiration and passwd aging
         */
        validate_account();

        /*
         * We only get here if we've been authenticated.
         */

        /*
         * Now we set up the environment for the new user, which includes
         * the users ulimit, nice value, ownership of this tty, uid, gid,
         * and environment variables.
         */
        if (Def_ulimit > 0L && ulimit(SET_FSIZ, Def_ulimit) < 0L)
                (void) printf("Could not set ULIMIT to %ld\n", Def_ulimit);

        /* di_devperm_login() sends detailed errors to syslog */
        if (di_devperm_login((const char *)ttyn, pwd->pw_uid, pwd->pw_gid,
            NULL) == -1) {
                (void) fprintf(stderr, "error processing /etc/logindevperm,"
                    " see syslog for more details\n");
        }

        adjust_nice();          /* passwd file can specify nice value */

        setup_credentials();    /* Set user credentials  - exits on failure */

        /*
         * NOTE: telnetd and rlogind rely upon this updating of utmpx
         * to indicate that the authentication completed  successfully,
         * pam_open_session was called and therefore they are required to
         * call pam_close_session.
         */
        update_utmpx_entry(sublogin);

        /* set the real (and effective) UID */
        if (setuid(pwd->pw_uid) == -1) {
                login_exit(1);
        }

        /*
         * Set up the basic environment for the exec.  This includes
         * HOME, PATH, LOGNAME, SHELL, TERM, TZ, HZ, and MAIL.
         */
        chdir_to_dir_user();

        establish_user_environment(renvp);

        (void) pam_end(pamh, PAM_SUCCESS);      /* Done using PAM */
        pamh = NULL;

        if (pwd->pw_uid == 0) {
                if (dosyslog) {
                        if (remote_host[0]) {
                                syslog(LOG_NOTICE, "ROOT LOGIN %s FROM %.*s",
                                    ttyn, HMAX, remote_host);
                        } else
                                syslog(LOG_NOTICE, "ROOT LOGIN %s", ttyn);
                }
        }
        closelog();

        (void) signal(SIGQUIT, SIG_DFL);
        (void) signal(SIGINT, SIG_DFL);

        /*
         * Display some useful information to the new user like the banner
         * and last login time if not a quiet login.
         */

        if (access(HUSHLOGIN, F_OK) != 0) {
                print_banner();
                display_last_login_time();
        }

        /*
         * Set SIGXCPU and SIGXFSZ to default disposition.
         * Shells inherit signal disposition from parent.
         * And the shells should have default dispositions
         * for the two below signals.
         */
        (void) signal(SIGXCPU, SIG_DFL);
        (void) signal(SIGXFSZ, SIG_DFL);

        /*
         * Now fire off the shell of choice
         */
        exec_the_shell();

        /*
         * All done
         */
        login_exit(1);
        return (0);
}


/*
 *                      *** Utility functions ***
 */



/*
 * donothing & catch    - Signal catching functions
 */

/*ARGSUSED*/
static void
donothing(int sig)
{
        if (pamh)
                (void) pam_end(pamh, PAM_ABORT);
}

#ifdef notdef
static  int     intrupt;

/*ARGSUSED*/
static void
catch(int sig)
{
        ++intrupt;
}
#endif

/*
 *                      *** Bad login logging support ***
 */

/*
 * badlogin()           - log to the log file 'trys'
 *                        unsuccessful attempts
 */

static void
badlogin(void)
{
        int retval, count1, fildes;

        /*
         * Tries to open the log file. If succeed, lock it and write
         * in the failed attempts
         */
        if ((fildes = open(LOGINLOG, O_APPEND|O_WRONLY)) != -1) {

                (void) sigset(SIGALRM, donothing);
                (void) alarm(L_WAITTIME);
                retval = lockf(fildes, F_LOCK, 0L);
                (void) alarm(0);
                (void) sigset(SIGALRM, SIG_DFL);
                if (retval == 0) {
                        for (count1 = 0; count1 < trys; count1++)
                                (void) write(fildes, log_entry[count1],
                                    (unsigned)strlen(log_entry[count1]));
                        (void) lockf(fildes, F_ULOCK, 0L);
                }
                (void) close(fildes);
        }
}


/*
 * log_bad_attempts     - log each bad login attempt - called from
 *                        login_authenticate.  Exits when the maximum attempt
 *                        count is exceeded.
 */

static void
log_bad_attempts(void)
{
        time_t timenow;

        if (trys >= LOGTRYS)
                return;
        if (writelog) {
                (void) time(&timenow);
                (void) strncat(log_entry[trys], user_name, LNAME_SIZE);
                (void) strncat(log_entry[trys], ":", (size_t)1);
                (void) strncat(log_entry[trys], ttyn, TTYN_SIZE);
                (void) strncat(log_entry[trys], ":", (size_t)1);
                (void) strncat(log_entry[trys], ctime(&timenow), TIME_SIZE);
                trys++;
        }
        if (count > flogin) {
                if ((pwd = getpwnam(user_name)) != NULL) {
                        if (remote_host[0]) {
                                syslog(LOG_NOTICE,
                                    "Login failure on %s from %.*s, "
                                    "%.*s", ttyn, HMAX, remote_host,
                                    NMAX, user_name);
                        } else {
                                syslog(LOG_NOTICE,
                                    "Login failure on %s, %.*s",
                                    ttyn, NMAX, user_name);
                        }
                } else {
                        if (remote_host[0]) {
                                syslog(LOG_NOTICE,
                                    "Login failure on %s from %.*s",
                                    ttyn, HMAX, remote_host);
                        } else {
                                syslog(LOG_NOTICE,
                                    "Login failure on %s", ttyn);
                        }
                }
        }
}


/*
 * turn_on_logging      - if the logfile exist, turn on attempt logging and
 *                        initialize the string storage area
 */

static void
turn_on_logging(void)
{
        struct stat dbuf;
        int i;

        if (stat(LOGINLOG, &dbuf) == 0) {
                writelog = 1;
                for (i = 0; i < LOGTRYS; i++) {
                        if (!(log_entry[i] = malloc((size_t)ENT_SIZE))) {
                                writelog = 0;
                                break;
                        }
                        *log_entry[i] = '\0';
                }
        }
}


/*
 * login_conv():
 *      This is the conv (conversation) function called from
 *      a PAM authentication module to print error messages
 *      or garner information from the user.
 */
static int
login_conv(int num_msg, const struct pam_message **msg,
    struct pam_response **response, void *appdata_ptr)
{
        const struct pam_message *m;
        struct pam_response *r;
        char *temp;
        int k, i;

        if (num_msg <= 0)
                return (PAM_CONV_ERR);

        *response = calloc(num_msg, sizeof (struct pam_response));
        if (*response == NULL)
                return (PAM_BUF_ERR);

        k = num_msg;
        m = *msg;
        r = *response;
        while (k--) {

                switch (m->msg_style) {

                case PAM_PROMPT_ECHO_OFF:
                        errno = 0;
                        temp = getpassphrase(m->msg);
                        if (temp != NULL) {
                                if (errno == EINTR)
                                        return (PAM_CONV_ERR);

                                r->resp = strdup(temp);
                                if (r->resp == NULL) {
                                        /* free responses */
                                        r = *response;
                                        for (i = 0; i < num_msg; i++, r++) {
                                                if (r->resp)
                                                        free(r->resp);
                                        }
                                        free(*response);
                                        *response = NULL;
                                        return (PAM_BUF_ERR);
                                }
                        }

                        m++;
                        r++;
                        break;

                case PAM_PROMPT_ECHO_ON:
                        if (m->msg != NULL)
                                (void) fputs(m->msg, stdout);
                        r->resp = calloc(1, PAM_MAX_RESP_SIZE);
                        if (r->resp == NULL) {
                                /* free responses */
                                r = *response;
                                for (i = 0; i < num_msg; i++, r++) {
                                        if (r->resp)
                                                free(r->resp);
                                }
                                free(*response);
                                *response = NULL;
                                return (PAM_BUF_ERR);
                        }
                        /*
                         * The response might include environment variables
                         * information. We should store that information in
                         * envp if there is any; otherwise, envp is set to
                         * NULL.
                         */
                        bzero((void *)inputline, MAXLINE);

                        envp = getargs(inputline);

                        /* If we read in any input, process it. */
                        if (inputline[0] != '\0') {
                                int len;

                                if (envp != (char **)NULL)
                                        /*
                                         * If getargs() did not return NULL,
                                         * *envp is the first string in
                                         * inputline. envp++ makes envp point
                                         * to environment variables information
                                         *  or be NULL.
                                         */
                                        envp++;

                                (void) strncpy(r->resp, inputline,
                                    PAM_MAX_RESP_SIZE-1);
                                r->resp[PAM_MAX_RESP_SIZE-1] = '\0';
                                len = strlen(r->resp);
                                if (r->resp[len-1] == '\n')
                                        r->resp[len-1] = '\0';
                        } else {
                                login_exit(1);
                        }
                        m++;
                        r++;
                        break;

                case PAM_ERROR_MSG:
                        if (m->msg != NULL) {
                                (void) fputs(m->msg, stderr);
                                (void) fputs("\n", stderr);
                        }
                        m++;
                        r++;
                        break;
                case PAM_TEXT_INFO:
                        if (m->msg != NULL) {
                                (void) fputs(m->msg, stdout);
                                (void) fputs("\n", stdout);
                        }
                        m++;
                        r++;
                        break;

                default:
                        break;
                }
        }
        return (PAM_SUCCESS);
}

/*
 * verify_passwd - Authenticates the user.
 *      Returns: PAM_SUCCESS if authentication successful,
 *               PAM error code if authentication fails.
 */

static int
verify_passwd(void)
{
        int error;
        const char *user;
        int flag = (Passreqflag ? PAM_DISALLOW_NULL_AUTHTOK : 0);

        /*
         * PAM authenticates the user for us.
         */
        error = pam_authenticate(pamh, flag);

        /* get the user_name from the pam handle */
        (void) pam_get_item(pamh, PAM_USER, (const void **)&user);

        if (user == NULL || *user == '\0')
                return (PAM_SYSTEM_ERR);

        SCPYL(user_name, user);
        check_for_dueling_unix(user_name);

        if (((pwd = getpwnam(user_name)) == NULL) &&
            (error != PAM_USER_UNKNOWN)) {
                return (PAM_SYSTEM_ERR);
        }

        return (error);
}

/*
 * quotec               - Called by getargs
 */

static int
quotec(void)
{
        int c, i, num;

        switch (c = getc(stdin)) {

                case 'n':
                        c = '\n';
                        break;

                case 'r':
                        c = '\r';
                        break;

                case 'v':
                        c = '\013';
                        break;

                case 'b':
                        c = '\b';
                        break;

                case 't':
                        c = '\t';
                        break;

                case 'f':
                        c = '\f';
                        break;

                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                        for (num = 0, i = 0; i < 3; i++) {
                                num = num * 8 + (c - '0');
                                if ((c = getc(stdin)) < '0' || c > '7')
                                        break;
                        }
                        (void) ungetc(c, stdin);
                        c = num & 0377;
                        break;

                default:
                        break;
        }
        return (c);
}

/*
 * getargs              - returns an input line.  Exits if EOF encountered.
 */
#define WHITESPACE      0
#define ARGUMENT        1

static char **
getargs(char *input_line)
{
        static char envbuf[MAXLINE];
        static char *args[MAXARGS];
        char *ptr, **answer;
        int c;
        int state;
        char *p = input_line;

        ptr = envbuf;
        answer = &args[0];
        state = WHITESPACE;

        while ((c = getc(stdin)) != EOF && answer < &args[MAXARGS-1]) {

                *(input_line++) = c;

                switch (c) {

                case '\n':
                        if (ptr == &envbuf[0])
                                return ((char **)NULL);
                        *input_line = *ptr = '\0';
                        *answer = NULL;
                        return (&args[0]);

                case ' ':
                case '\t':
                        if (state == ARGUMENT) {
                                *ptr++ = '\0';
                                state = WHITESPACE;
                        }
                        break;

                case '\\':
                        c = quotec();
                        /* FALLTHROUGH */

                default:
                        if (state == WHITESPACE) {
                                *answer++ = ptr;
                                state = ARGUMENT;
                        }
                        *ptr++ = c;
                }

                /* Attempt at overflow, exit */
                if (input_line - p >= MAXLINE - 1 ||
                    ptr >= &envbuf[sizeof (envbuf) - 1]) {
                        audit_error = ADT_FAIL_VALUE_INPUT_OVERFLOW;
                        login_exit(1);
                }
        }

        /*
         * If we left loop because an EOF was received or we've overflown
         * args[], exit immediately.
         */
        login_exit(0);
        /* NOTREACHED */
}

/*
 * get_user_name        - Gets the user name either passed in, or from the
 *                        login: prompt.
 */

static void
get_user_name(void)
{
        FILE    *fp;

        if ((fp = fopen(ISSUEFILE, "r")) != NULL) {
                char    *ptr, buffer[BUFSIZ];
                while ((ptr = fgets(buffer, sizeof (buffer), fp)) != NULL) {
                        (void) fputs(ptr, stdout);
                }
                (void) fclose(fp);
        }

        /*
         * if TTYPROMPT is not set, use our own prompt
         * otherwise, use ttyprompt. We just set PAM_USER_PROMPT
         * and let the module do the prompting.
         */

        if ((ttyprompt == NULL) || (*ttyprompt == '\0'))
                (void) pam_set_item(pamh, PAM_USER_PROMPT, (void *)loginmsg);
        else
                (void) pam_set_item(pamh, PAM_USER_PROMPT, (void *)ttyprompt);

        envp = &zero; /* XXX: is this right? */
}


/*
 * Check_for_dueling_unix   -   Check to see if the another login is talking
 *                              to the line we've got open as a login port
 *                              Exits if we're talking to another unix system
 */

static void
check_for_dueling_unix(char *inputline)
{
        if (EQN(loginmsg, inputline) || EQN(passwdmsg, inputline) ||
            EQN(incorrectmsg, inputline)) {
                (void) printf("Looking at a login line.\n");
                login_exit(8);
        }
}

/*
 * logins_disabled -    if the file /etc/nologin exists and the user is not
 *                      root then do not permit them to login
 */
static int
logins_disabled(char *user_name)
{
        FILE    *nlfd;
        int     c;
        if (!EQN("root", user_name) &&
            ((nlfd = fopen(NOLOGIN, "r")) != (FILE *)NULL)) {
                while ((c = getc(nlfd)) != EOF)
                        (void) putchar(c);
                (void) fflush(stdout);
                (void) sleep(5);
                return (TRUE);
        }
        return (FALSE);
}

#define DEFAULT_CONSOLE "/dev/console"

/*
 * check_for_console -  Checks if we're getting a root login on the
 *                      console, or a login from the global zone. Exits if not.
 *
 * If CONSOLE is set to /dev/console in /etc/default/login, then root logins
 * on /dev/vt/# are permitted as well. /dev/vt/# does not exist in non-global
 * zones, but checking them does no harm.
 */
static void
check_for_console(void)
{
        const char *consoles[] = { "/dev/console", "/dev/vt/", NULL };
        int i;

        if (pwd == NULL || pwd->pw_uid != 0 || zflag != B_FALSE ||
            Console == NULL)
                return;

        if (strcmp(Console, DEFAULT_CONSOLE) == 0) {
                for (i = 0; consoles[i] != NULL; i ++) {
                        if (strncmp(ttyn, consoles[i],
                            strlen(consoles[i])) == 0)
                                return;
                }
        } else {
                if (strcmp(ttyn, Console) == 0)
                        return;
        }

        (void) printf("Not on system console\n");

        audit_error = ADT_FAIL_VALUE_CONSOLE;
        login_exit(10);

}

/*
 * List of environment variables or environment variable prefixes that should
 * not be propagated across logins, such as when the login -p option is used.
 */
static const char *const illegal[] = {
        "SHELL=",
        "HOME=",
        "LOGNAME=",
#ifndef NO_MAIL
        "MAIL=",
#endif
        "CDPATH=",
        "IFS=",
        "PATH=",
        "LD_",
        "SMF_",
        NULL
};

/*
 * legalenvvar          - Is it legal to insert this environmental variable?
 */

static int
legalenvvar(char *s)
{
        const char *const *p;

        for (p = &illegal[0]; *p; p++) {
                if (strncmp(s, *p, strlen(*p)) == 0)
                        return (0);
        }

        return (1);
}


/*
 * getstr               - Get a string from standard input
 *                        Calls exit if read(2) fails.
 */

static void
getstr(char *buf, int cnt, char *err)
{
        char c;

        do {
                if (read(0, &c, 1) != 1)
                        login_exit(1);
                *buf++ = c;
        } while (--cnt > 1 && c != 0);

        *buf = 0;
        err = err;      /* For lint */
}


/*
 * defaults             - read defaults
 */

static void
defaults(void)
{
        int  flags;
        char *ptr;

        if (defopen(Pndefault) == 0) {
                /*
                 * ignore case
                 */
                flags = defcntl(DC_GETFLAGS, 0);
                TURNOFF(flags, DC_CASE);
                (void) defcntl(DC_SETFLAGS, flags);

                if ((Console = defread("CONSOLE=")) != NULL)
                        Console = strdup(Console);

                if ((Altshell = defread("ALTSHELL=")) != NULL)
                        Altshell = strdup(Altshell);

                if ((ptr = defread("PASSREQ=")) != NULL &&
                    strcasecmp("YES", ptr) == 0)
                                Passreqflag = 1;

                if ((Def_tz = defread("TIMEZONE=")) != NULL)
                        Def_tz = strdup(Def_tz);

                if ((Def_hertz = defread("HZ=")) != NULL)
                        Def_hertz = strdup(Def_hertz);

                if ((Def_path   = defread("PATH=")) != NULL)
                        Def_path = strdup(Def_path);

                if ((Def_supath = defread("SUPATH=")) != NULL)
                        Def_supath = strdup(Def_supath);

                if ((ptr = defread("ULIMIT=")) != NULL)
                        Def_ulimit = atol(ptr);

                if ((ptr = defread("TIMEOUT=")) != NULL)
                        Def_timeout = (unsigned)atoi(ptr);

                if ((ptr = defread("UMASK=")) != NULL)
                        if (sscanf(ptr, "%lo", &Umask) != 1)
                                Umask = DEFUMASK;

                if ((ptr = defread("SLEEPTIME=")) != NULL) {
                        if (is_number(ptr))
                                Sleeptime = atoi(ptr);
                }

                if ((ptr = defread("DISABLETIME=")) != NULL) {
                        if (is_number(ptr))
                                Disabletime = atoi(ptr);
                }

                if ((ptr = defread("SYSLOG=")) != NULL)
                        dosyslog = strcmp(ptr, "YES") == 0;

                if ((ptr = defread("RETRIES=")) != NULL) {
                        if (is_number(ptr))
                                retry = atoi(ptr);
                }

                if ((ptr = defread("SYSLOG_FAILED_LOGINS=")) != NULL) {
                        if (is_number(ptr))
                                flogin = atoi(ptr);
                        else
                                flogin = retry;
                } else
                        flogin = retry;
                (void) defopen((char *)NULL);
        }
}


/*
 * get_options(argc, argv)
 *                      - parse the cmd line.
 *                      - return 0 if successful, -1 if failed.
 *                      Calls login_exit() on misuse of -r, -h, and -z flags
 */

static  int
get_options(int argc, char *argv[])
{
        int     c;
        int     errflg = 0;
        char    sflagname[NMAX+1];
        const   char *flags_message = "Only one of -r, -h and -z allowed\n";

        while ((c = getopt(argc, argv, "u:s:R:f:h:r:pad:t:U:z:")) != -1) {
                switch (c) {
                case 'a':
                        break;

                case 'd':
                        /*
                         * Must be root to pass in device name
                         * otherwise we exit() as punishment for trying.
                         */
                        if (getuid() != 0 || geteuid() != 0) {
                                audit_error = ADT_FAIL_VALUE_DEVICE_PERM;
                                login_exit(1);  /* sigh */
                                /*NOTREACHED*/
                        }
                        ttyn = optarg;
                        break;

                case 'h':
                        if (hflag || rflag || zflag) {
                                (void) fprintf(stderr, flags_message);
                                login_exit(1);
                        }
                        hflag = B_TRUE;
                        SCPYL(remote_host, optarg);
                        if (argv[optind]) {
                                if (argv[optind][0] != '-') {
                                        SCPYL(terminal, argv[optind]);
                                        optind++;
                                } else {
                                        /*
                                         * Allow "login -h hostname -" to
                                         * skip setting up an username as "-".
                                         */
                                        if (argv[optind][1] == '\0')
                                                optind++;
                                }

                        }
                        SCPYL(progname, "telnet");
                        break;

                case 'r':
                        if (hflag || rflag || zflag) {
                                (void) fprintf(stderr, flags_message);
                                login_exit(1);
                        }
                        rflag = B_TRUE;
                        SCPYL(remote_host, optarg);
                        SCPYL(progname, "rlogin");
                        break;

                case 'p':
                        pflag = B_TRUE;
                        break;

                case 'f':
                        /*
                         * Must be root to bypass authentication
                         * otherwise we exit() as punishment for trying.
                         */
                        if (getuid() != 0 || geteuid() != 0) {
                                audit_error = ADT_FAIL_VALUE_AUTH_BYPASS;

                                login_exit(1);  /* sigh */
                                /*NOTREACHED*/
                        }
                        /* save fflag user name for future use */
                        SCPYL(user_name, optarg);
                        fflag = B_TRUE;
                        break;
                case 'u':
                        if (!strlen(optarg)) {
                                (void) fprintf(stderr,
                                    "Empty string supplied with -u\n");
                                login_exit(1);
                        }
                        SCPYL(identity, optarg);
                        uflag = B_TRUE;
                        break;
                case 's':
                        if (!strlen(optarg)) {
                                (void) fprintf(stderr,
                                    "Empty string supplied with -s\n");
                                login_exit(1);
                        }
                        SCPYL(sflagname, optarg);
                        sflag = B_TRUE;
                        break;
                case 'R':
                        if (!strlen(optarg)) {
                                (void) fprintf(stderr,
                                    "Empty string supplied with -R\n");
                                login_exit(1);
                        }
                        SCPYL(repository, optarg);
                        Rflag = B_TRUE;
                        break;
                case 't':
                        if (!strlen(optarg)) {
                                (void) fprintf(stderr,
                                    "Empty string supplied with -t\n");
                                login_exit(1);
                        }
                        SCPYL(terminal, optarg);
                        tflag = B_TRUE;
                        break;
                case 'U':
                        /*
                         * Kerberized rlogind may fork us with
                         * -U "" if the rlogin client used the "-a"
                         * option to send a NULL username.  This is done
                         * to force login to prompt for a user/password.
                         * However, if Kerberos auth was used, we dont need
                         * to prompt, so we will accept the option and
                         * handle the situation later.
                         */
                        SCPYL(rusername, optarg);
                        Uflag = B_TRUE;
                        break;
                case 'z':
                        if (hflag || rflag || zflag) {
                                (void) fprintf(stderr, flags_message);
                                login_exit(1);
                        }
                        (void) snprintf(zone_name, sizeof (zone_name),
                            "zone:%s", optarg);
                        SCPYL(progname, "zlogin");
                        zflag = B_TRUE;
                        break;
                default:
                        errflg++;
                        break;
                }       /* end switch */
        }               /* end while */

        /*
         * If the 's svcname' flag was used, override the progname
         * value that is to be used in the pam_start call.
         */
        if (sflag)
                SCPYL(progname, sflagname);

        /*
         * get the prompt set by ttymon
         */
        ttyprompt = getenv("TTYPROMPT");

        if ((ttyprompt != NULL) && (*ttyprompt != '\0')) {
                /*
                 * if ttyprompt is set, there should be data on
                 * the stream already.
                 */
                if ((envp = getargs(inputline)) != (char **)NULL) {
                        /*
                         * don't get name if name passed as argument.
                         */
                        SCPYL(user_name, *envp++);
                }
        } else if (optind < argc) {
                SCPYL(user_name, argv[optind]);
                (void) SCPYL(inputline, user_name);
                (void) strlcat(inputline, "   \n", sizeof (inputline));
                envp = &argv[optind+1];

                if (!fflag)
                        SCPYL(lusername, user_name);
        }

        if (errflg)
                return (-1);
        return (0);
}

/*
 * usage                - Print usage message
 *
 */
static void
usage(void)
{
        (void) fprintf(stderr,
            "usage:\n"
            "    login [-p] [-d device] [-R repository] [-s service]\n"
            "\t[-t terminal]  [-u identity] [-U ruser]\n"
            "\t[-h hostname [terminal] | -r hostname] [name [environ]...]\n");

}

/*
 * doremoteterm         - Sets the appropriate ioctls for a remote terminal
 */
static char     *speeds[] = {
        "0", "50", "75", "110", "134", "150", "200", "300",
        "600", "1200", "1800", "2400", "4800", "9600", "19200", "38400",
        "57600", "76800", "115200", "153600", "230400", "307200", "460800",
        "921600", "1000000", "1152000", "1500000", "2000000", "2500000",
        "3000000", "3500000", "4000000"
};

#define NSPEEDS (sizeof (speeds) / sizeof (speeds[0]))


static void
doremoteterm(char *term)
{
        struct termios tp;
        char *cp = strchr(term, '/'), **cpp;
        char *speed;

        (void) ioctl(0, TCGETS, &tp);

        if (cp) {
                *cp++ = '\0';
                speed = cp;
                cp = strchr(speed, '/');

                if (cp)
                        *cp++ = '\0';

                for (cpp = speeds; cpp < &speeds[NSPEEDS]; cpp++) {
                        if (strcmp(*cpp, speed) == 0) {
                                (void) cfsetospeed(&tp, cpp-speeds);
                                break;
                        }
                }
        }

        tp.c_lflag |= ECHO|ICANON;
        tp.c_iflag |= IGNPAR|ICRNL;

        (void) ioctl(0, TCSETS, &tp);

}

/*
 * Process_rlogin               - Does the work that rlogin and telnet
 *                                need done
 */
static void
process_rlogin(void)
{
        /*
         * If a Kerberized rlogin was initiated, then these fields
         * must be read by rlogin daemon itself and passed down via
         * cmd line args.
         */
        if (!Uflag && !strlen(rusername))
                getstr(rusername, sizeof (rusername), "remuser");
        if (!strlen(lusername))
                getstr(lusername, sizeof (lusername), "locuser");
        if (!tflag && !strlen(terminal))
                getstr(terminal, sizeof (terminal), "Terminal type");

        if (strlen(terminal))
                doremoteterm(terminal);

        /* fflag has precedence over stuff passed by rlogind */
        if (fflag || getuid()) {
                pwd = &nouser;
                return;
        } else {
                if (pam_set_item(pamh, PAM_USER, lusername) != PAM_SUCCESS)
                        login_exit(1);

                pwd = getpwnam(lusername);
                if (pwd == NULL) {
                        pwd = &nouser;
                        return;
                }
        }

        /*
         * Update PAM on the user name
         */
        if (strlen(lusername) &&
            pam_set_item(pamh, PAM_USER, lusername) != PAM_SUCCESS)
                login_exit(1);

        if (strlen(rusername) &&
            pam_set_item(pamh, PAM_RUSER, rusername) != PAM_SUCCESS)
                login_exit(1);

        SCPYL(user_name, lusername);
        envp = &zero;
        lusername[0] = '\0';
}

/*
 *              *** Account validation routines ***
 *
 */

/*
 * validate_account             - This is the PAM version of validate.
 */

static void
validate_account(void)
{
        int     error;
        int     flag;
        int     tries;          /* new password retries */

        (void) alarm(0);        /* give user time to come up with password */

        check_log();

        if (Passreqflag)
                flag = PAM_DISALLOW_NULL_AUTHTOK;
        else
                flag = 0;

        if ((error = pam_acct_mgmt(pamh, flag)) != PAM_SUCCESS) {
                if (error == PAM_NEW_AUTHTOK_REQD) {
                        tries = 1;
                        error = PAM_AUTHTOK_ERR;
                        while (error == PAM_AUTHTOK_ERR &&
                            tries <= DEF_ATTEMPTS) {
                                if (tries > 1)
                                        (void) printf("Try again\n\n");

                                (void) printf("Choose a new password.\n");

                                error = pam_chauthtok(pamh,
                                    PAM_CHANGE_EXPIRED_AUTHTOK);
                                if (error == PAM_TRY_AGAIN) {
                                        (void) sleep(1);
                                        error = pam_chauthtok(pamh,
                                            PAM_CHANGE_EXPIRED_AUTHTOK);
                                }
                                tries++;
                        }

                        if (error != PAM_SUCCESS) {
                                if (dosyslog)
                                        syslog(LOG_CRIT,
                                            "change password failure: %s",
                                            pam_strerror(pamh, error));
                                audit_error = ADT_FAIL_PAM + error;
                                login_exit(1);
                        } else {
                                audit_success(ADT_passwd, pwd, zone_name);
                        }
                } else {
                        (void) printf(incorrectmsg);

                        if (dosyslog)
                                syslog(LOG_CRIT,
                                    "login account failure: %s",
                                    pam_strerror(pamh, error));
                        audit_error = ADT_FAIL_PAM + error;
                        login_exit(1);
                }
        }
}

/*
 * Check_log    - This is really a hack because PAM checks the log, but login
 *                wants to know if the log is okay and PAM doesn't have
 *                a module independent way of handing this info back.
 */

static void
check_log(void)
{
        int fdl;
        long long offset;

        offset = (long long) pwd->pw_uid * (long long) sizeof (struct lastlog);

        if ((fdl = open(LASTLOG, O_RDWR|O_CREAT, 0444)) >= 0) {
                if (llseek(fdl, offset, SEEK_SET) == offset &&
                    read(fdl, (char *)&ll, sizeof (ll)) == sizeof (ll) &&
                    ll.ll_time != 0)
                        lastlogok = 1;
                (void) close(fdl);
        }
}

/*
 * chdir_to_dir_user    - Now chdir after setuid/setgid have happened to
 *                        place us in the user's home directory just in
 *                        case it was protected and the first chdir failed.
 *                        No chdir errors should happen at this point because
 *                        all failures should have happened on the first
 *                        time around.
 */

static void
chdir_to_dir_user(void)
{
        if (chdir(pwd->pw_dir) < 0) {
                if (chdir("/") < 0) {
                        (void) printf("No directory!\n");
                        /*
                         * This probably won't work since we can't get to /.
                         */
                        if (dosyslog) {
                                if (remote_host[0]) {
                                        syslog(LOG_CRIT,
                                            "LOGIN FAILURES ON %s FROM %.*s ",
                                            " %.*s", ttyn, HMAX,
                                            remote_host, NMAX, pwd->pw_name);
                                } else {
                                        syslog(LOG_CRIT,
                                            "LOGIN FAILURES ON %s, %.*s",
                                            ttyn, NMAX, pwd->pw_name);
                                }
                        }
                        closelog();
                        (void) sleep(Disabletime);
                        exit(1);
                } else {
                        (void) printf("No directory! Logging in with home=/\n");
                        pwd->pw_dir = "/";
                }
        }
}


/*
 * login_authenticate   - Performs the main authentication work
 *                        1. Prints the login prompt
 *                        2. Requests and verifys the password
 *                        3. Checks the port password
 */

static void
login_authenticate(void)
{
        const char *user;
        int err;
        int login_successful = 0;

        do {
                /* if scheme broken, then nothing to do but quit */
                if (pam_get_item(pamh, PAM_USER, (const void **)&user) !=
                    PAM_SUCCESS) {
                        exit(1);
                }

                /*
                 * only get name from utility if it is not already
                 * supplied by pam_start or a pam_set_item.
                 */
                if (!user || !user[0]) {
                        /* use call back to get user name */
                        get_user_name();
                }

                err = verify_passwd();

                /*
                 * If root login and not on system console then call exit(2)
                 */
                check_for_console();

                switch (err) {
                case PAM_SUCCESS:
                case PAM_NEW_AUTHTOK_REQD:
                        /*
                         * Officially, pam_authenticate() shouldn't return this
                         * but it's probably the right thing to return if
                         * PAM_DISALLOW_NULL_AUTHTOK is set so the user will
                         * be forced to change password later in this code.
                         */
                        count = 0;
                        login_successful = 1;
                        break;
                case PAM_MAXTRIES:
                        count = retry;
                        /*FALLTHROUGH*/
                case PAM_AUTH_ERR:
                case PAM_AUTHINFO_UNAVAIL:
                case PAM_USER_UNKNOWN:
                        audit_failure(get_audit_id(), ADT_FAIL_PAM + err, pwd,
                            remote_host, ttyn, zone_name);
                        log_bad_attempts();
                        break;
                case PAM_ABORT:
                        log_bad_attempts();
                        (void) sleep(Disabletime);
                        (void) printf(incorrectmsg);

                        audit_error = ADT_FAIL_PAM + err;
                        login_exit(1);
                        /*NOTREACHED*/
                default:        /* Some other PAM error */
                        audit_error = ADT_FAIL_PAM + err;
                        login_exit(1);
                        /*NOTREACHED*/
                }

                if (login_successful)
                        break;

                /* sleep after bad passwd */
                if (count)
                        (void) sleep(Sleeptime);
                (void) printf(incorrectmsg);
                /* force name to be null in this case */
                if (pam_set_item(pamh, PAM_USER, NULL) != PAM_SUCCESS)
                        login_exit(1);
                if (pam_set_item(pamh, PAM_RUSER, NULL) != PAM_SUCCESS)
                        login_exit(1);
        } while (count++ < retry);

        if (count >= retry) {
                audit_failure(get_audit_id(), ADT_FAIL_VALUE_MAX_TRIES, pwd,
                    remote_host, ttyn, zone_name);
                /*
                 * If logging is turned on, output the
                 * string storage area to the log file,
                 * and sleep for Disabletime
                 * seconds before exiting.
                 */
                if (writelog)
                        badlogin();
                if (dosyslog) {
                        if ((pwd = getpwnam(user_name)) != NULL) {
                                if (remote_host[0]) {
                                        syslog(LOG_CRIT,
                                            "REPEATED LOGIN FAILURES ON %s "
                                            "FROM %.*s, %.*s",
                                            ttyn, HMAX, remote_host, NMAX,
                                            user_name);
                                } else {
                                        syslog(LOG_CRIT,
                                            "REPEATED LOGIN FAILURES ON "
                                            "%s, %.*s",
                                            ttyn, NMAX, user_name);
                                }
                        } else {
                                if (remote_host[0]) {
                                        syslog(LOG_CRIT,
                                            "REPEATED LOGIN FAILURES ON %s "
                                            "FROM %.*s",
                                            ttyn, HMAX, remote_host);
                                } else {
                                        syslog(LOG_CRIT,
                                            "REPEATED LOGIN FAILURES ON %s",
                                            ttyn);
                                }
                        }
                }
                (void) sleep(Disabletime);
                exit(1);
        }

}

/*
 *                      *** Credential Related routines ***
 *
 */

/*
 * setup_credentials            - sets the group ID, initializes the groups
 *                                and sets up the secretkey.
 *                                Exits if a failure occurrs.
 */


/*
 * setup_credentials            - PAM does all the work for us on this one.
 */

static void
setup_credentials(void)
{
        int     error = 0;

        /* set the real (and effective) GID */
        if (setgid(pwd->pw_gid) == -1) {
                login_exit(1);
        }

        /*
         * Initialize the supplementary group access list.
         */
        if ((user_name[0] == '\0') ||
            (initgroups(user_name, pwd->pw_gid) == -1)) {
                audit_error = ADT_FAIL_VALUE_PROGRAM;
                login_exit(1);
        }

        if ((error = pam_setcred(pamh, zflag ? PAM_REINITIALIZE_CRED :
            PAM_ESTABLISH_CRED)) != PAM_SUCCESS) {
                audit_error = ADT_FAIL_PAM + error;
                login_exit(error);
        }

        /*
         * Record successful login and fork process that records logout.
         * We have to do this after setting credentials because pam_setcred()
         * loads key audit info into the cred, but before setuid() so audit
         * system calls will work.
         */
        audit_success(get_audit_id(), pwd, zone_name);
}

static uint_t
get_audit_id(void)
{
        if (rflag)
                return (ADT_rlogin);
        else if (hflag)
                return (ADT_telnet);
        else if (zflag)
                return (ADT_zlogin);

        return (ADT_login);
}

/*
 *
 *              *** Routines to get a new user set up and running ***
 *
 *                      Things to do when starting up a new user:
 *                              adjust_nice
 *                              update_utmpx_entry
 *                              establish_user_environment
 *                              print_banner
 *                              display_last_login_time
 *                              exec_the_shell
 *
 */


/*
 * adjust_nice          - Set the nice (process priority) value if the
 *                        gecos value contains an appropriate value.
 */

static void
adjust_nice(void)
{
        int pri, mflg, i;

        if (strncmp("pri=", pwd->pw_gecos, 4) == 0) {
                pri = 0;
                mflg = 0;
                i = 4;

                if (pwd->pw_gecos[i] == '-') {
                        mflg++;
                        i++;
                }

                while (pwd->pw_gecos[i] >= '0' && pwd->pw_gecos[i] <= '9')
                        pri = (pri * 10) + pwd->pw_gecos[i++] - '0';

                if (mflg)
                        pri = -pri;

                (void) nice(pri);
        }
}

/*
 * update_utmpx_entry   - Searchs for the correct utmpx entry, making an
 *                        entry there if it finds one, otherwise exits.
 */

static void
update_utmpx_entry(int sublogin)
{
        int err;
        const char *user;
        static char *errmsg = "No utmpx entry. "
            "You must exec \"login\" from the lowest level \"shell\".";
        int tmplen;
        struct utmpx *u = NULL;
        struct utmpx utmpx;
        char *ttyntail;

        /*
         * If we're not a sublogin then
         * we'll get an error back if our PID doesn't match the PID of the
         * entry we are updating, otherwise if its a sublogin the flags
         * field is set to 0, which means we just write a matching entry
         * (without checking the pid), or a new entry if an entry doesn't
         * exist.
         */

        if ((err = pam_open_session(pamh, 0)) != PAM_SUCCESS) {
                audit_error = ADT_FAIL_PAM + err;
                login_exit(1);
        }

        if ((err = pam_get_item(pamh, PAM_USER, (const void **)&user)) !=
            PAM_SUCCESS) {
                audit_error = ADT_FAIL_PAM + err;
                login_exit(1);
        }

        (void) memset((void *)&utmpx, 0, sizeof (utmpx));
        (void) time(&utmpx.ut_tv.tv_sec);
        utmpx.ut_pid = getpid();

        if (rflag || hflag) {
                SCPYN(utmpx.ut_host, remote_host);
                tmplen = strlen(remote_host) + 1;
                if (tmplen < sizeof (utmpx.ut_host))
                        utmpx.ut_syslen = tmplen;
                else
                        utmpx.ut_syslen = sizeof (utmpx.ut_host);
        } else if (zflag) {
                /*
                 * If this is a login from another zone, put the
                 * zone:<zonename> string in the utmpx entry.
                 */
                SCPYN(utmpx.ut_host, zone_name);
                tmplen = strlen(zone_name) + 1;
                if (tmplen < sizeof (utmpx.ut_host))
                        utmpx.ut_syslen = tmplen;
                else
                        utmpx.ut_syslen = sizeof (utmpx.ut_host);
        } else {
                utmpx.ut_syslen = 0;
        }

        SCPYN(utmpx.ut_user, user);

        /* skip over "/dev/" */
        ttyntail = basename(ttyn);

        while ((u = getutxent()) != NULL) {
                if ((u->ut_type == INIT_PROCESS ||
                    u->ut_type == LOGIN_PROCESS ||
                    u->ut_type == USER_PROCESS) &&
                    ((sublogin && strncmp(u->ut_line, ttyntail,
                    sizeof (u->ut_line)) == 0) ||
                    u->ut_pid == login_pid)) {
                        SCPYN(utmpx.ut_line, (ttyn+sizeof ("/dev/")-1));
                        (void) memcpy(utmpx.ut_id, u->ut_id,
                            sizeof (utmpx.ut_id));
                        utmpx.ut_exit.e_exit = u->ut_exit.e_exit;
                        utmpx.ut_type = USER_PROCESS;
                        (void) pututxline(&utmpx);
                        break;
                }
        }
        endutxent();

        if (u == (struct utmpx *)NULL) {
                if (!sublogin) {
                        /*
                         * no utmpx entry already setup
                         * (init or rlogind/telnetd)
                         */
                        (void) puts(errmsg);

                        audit_error = ADT_FAIL_VALUE_PROGRAM;
                        login_exit(1);
                }
        } else {
                /* Now attempt to write out this entry to the wtmp file if */
                /* we were successful in getting it from the utmpx file and */
                /* the wtmp file exists.                                   */
                updwtmpx(WTMPX_FILE, &utmpx);
        }
}



/*
 * process_chroot_logins        - Chroots to the specified subdirectory and
 *                                re executes login.
 */

static int
process_chroot_logins(void)
{
        /*
         * If the shell field starts with a '*', do a chroot to the home
         * directory and perform a new login.
         */

        if (*pwd->pw_shell == '*') {
                (void) pam_end(pamh, PAM_SUCCESS);      /* Done using PAM */
                pamh = NULL;                            /* really done */
                if (chroot(pwd->pw_dir) < 0) {
                        (void) printf("No Root Directory\n");

                        audit_failure(get_audit_id(),
                            ADT_FAIL_VALUE_CHDIR_FAILED,
                            pwd, remote_host, ttyn, zone_name);

                        return (ERROR);
                }
                /*
                 * Set the environment flag <!sublogin> so that the next login
                 * knows that it is a sublogin.
                 */
                envinit[0] = SUBLOGIN;
                envinit[1] = (char *)NULL;
                (void) printf("Subsystem root: %s\n", pwd->pw_dir);
                (void) execle("/usr/bin/login", "login", (char *)0,
                    &envinit[0]);
                (void) execle("/etc/login", "login", (char *)0, &envinit[0]);
                (void) printf("No /usr/bin/login or /etc/login on root\n");

                audit_error = ADT_FAIL_VALUE_PROGRAM;

                login_exit(1);
        }
        return (OK);
}

/*
 * establish_user_environment   - Set up the new users enviornment
 */

static void
establish_user_environment(char **renvp)
{
        int i, j, k, l_index, length, idx = 0;
        char *endptr;
        char **lenvp;
        char **pam_env;

        lenvp = environ;
        while (*lenvp++)
                ;

        /* count the number of PAM environment variables set by modules */
        if ((pam_env = pam_getenvlist(pamh)) != 0) {
                for (idx = 0; pam_env[idx] != 0; idx++)
                                ;
        }

        envinit = (char **)calloc(lenvp - environ + 10 + MAXARGS + idx,
            sizeof (char *));
        if (envinit == NULL) {
                (void) printf("Calloc failed - out of swap space.\n");
                login_exit(8);
        }

        /*
         * add PAM environment variables first so they
         * can be overwritten at login's discretion.
         * check for illegal environment variables.
         */
        idx = 0;        basicenv = 0;
        if (pam_env != 0) {
                while (pam_env[idx] != 0) {
                        if (legalenvvar(pam_env[idx])) {
                                envinit[basicenv] = pam_env[idx];
                                basicenv++;
                        }
                        idx++;
                }
        }
        (void) memcpy(&envinit[basicenv], newenv, sizeof (newenv));

        /* Set up environment */
        if (rflag) {
                ENVSTRNCAT(term, terminal);
        } else if (hflag) {
                if (strlen(terminal)) {
                        ENVSTRNCAT(term, terminal);
                }
        } else {
                char *tp = getenv("TERM");

                if ((tp != NULL) && (*tp != '\0'))
                        ENVSTRNCAT(term, tp);
        }

        ENVSTRNCAT(logname, pwd->pw_name);

        /*
         * There are three places to get timezone info.  init.c sets
         * TZ if the file /etc/default/init contains a value for TZ.
         * login.c looks in the file /etc/default/login for a
         * variable called TIMEZONE being set.  If TIMEZONE has a
         *  value, TZ is set to that value; no environment variable
         * TIMEZONE is set, only TZ.  If neither of these methods
         * work to set TZ, then the library routines  will default
         * to using the file /usr/lib/locale/TZ/localtime.
         *
         * There is a priority set up here.  If /etc/default/init has
         * a value for TZ, that value remains top priority.  If the
         * file /etc/default/login has TIMEZONE set, that has second
         * highest priority not overriding the value of TZ in
         * /etc/default/init.  The reason for this priority is that the
         * file /etc/default/init is supposed to be sourced by
         * /etc/profile.  We are doing the "sourcing" prematurely in
         * init.c.  Additionally, a login C shell doesn't source the
         * file /etc/profile thus not sourcing /etc/default/init thus not
         * allowing an adminstrator to globally set TZ for all users
         */
        if (Def_tz != NULL)     /* Is there a TZ from defaults/login? */
                tmp_tz = Def_tz;

        if ((Def_tz = getenv("TZ")) != NULL) {
                ENVSTRNCAT(timez, Def_tz);
        } else if (tmp_tz != NULL) {
                Def_tz = tmp_tz;
                ENVSTRNCAT(timez, Def_tz);
        }

        if (Def_hertz == NULL)
                (void) sprintf(hertz + strlen(hertz), "%lu", HZ);
        else
                ENVSTRNCAT(hertz, Def_hertz);

        if (Def_path == NULL)
                (void) strlcat(path, DEF_PATH, sizeof (path));
        else
                ENVSTRNCAT(path, Def_path);

        ENVSTRNCAT(home, pwd->pw_dir);

        /*
         * Find the end of the basic environment
         */
        for (basicenv = 0; envinit[basicenv] != NULL; basicenv++)
                ;

        /*
         * If TZ has a value, add it.
         */
        if (strcmp(timez, "TZ=") != 0)
                envinit[basicenv++] = timez;

        if (*pwd->pw_shell == '\0') {
                /*
                 * If possible, use the primary default shell,
                 * otherwise, use the secondary one.
                 */
                if (access(SHELL, X_OK) == 0)
                        pwd->pw_shell = SHELL;
                else
                        pwd->pw_shell = SHELL2;
        } else if (Altshell != NULL && strcmp(Altshell, "YES") == 0) {
                envinit[basicenv++] = shell;
                ENVSTRNCAT(shell, pwd->pw_shell);
        }

#ifndef NO_MAIL
        envinit[basicenv++] = mail;
        (void) strlcat(mail, pwd->pw_name, sizeof (mail));
#endif

        /*
         * Pick up locale environment variables, if any.
         */
        lenvp = renvp;
        while (*lenvp != NULL) {
                j = 0;
                while (localeenv[j] != 0) {
                        /*
                         * locale_envmatch() returns 1 if
                         * *lenvp is localenev[j] and valid.
                         */
                        if (locale_envmatch(localeenv[j], *lenvp) == 1) {
                                envinit[basicenv++] = *lenvp;
                                break;
                        }
                        j++;
                }
                lenvp++;
        }

        /*
         * If '-p' flag, then try to pass on allowable environment
         * variables.  Note that by processing this first, what is
         * passed on the final "login:" line may over-ride the invocation
         * values.  XXX is this correct?
         */
        if (pflag) {
                for (lenvp = renvp; *lenvp; lenvp++) {
                        if (!legalenvvar(*lenvp)) {
                                continue;
                        }
                        /*
                         * If this isn't 'xxx=yyy', skip it.  XXX
                         */
                        if ((endptr = strchr(*lenvp, '=')) == NULL) {
                                continue;
                        }
                        length = endptr + 1 - *lenvp;
                        for (j = 0; j < basicenv; j++) {
                                if (strncmp(envinit[j], *lenvp, length) == 0) {
                                        /*
                                         * Replace previously established value
                                         */
                                        envinit[j] = *lenvp;
                                        break;
                                }
                        }
                        if (j == basicenv) {
                                /*
                                 * It's a new definition, so add it at the end.
                                 */
                                envinit[basicenv++] = *lenvp;
                        }
                }
        }

        /*
         * Add in all the environment variables picked up from the
         * argument list to "login" or from the user response to the
         * "login" request, if any.
         */

        if (envp == NULL)
                goto switch_env;        /* done */

        for (j = 0, k = 0, l_index = 0;
            *envp != NULL && j < (MAXARGS-1);
            j++, envp++) {

                /*
                 * Scan each string provided.  If it doesn't have the
                 * format xxx=yyy, then add the string "Ln=" to the beginning.
                 */
                if ((endptr = strchr(*envp, '=')) == NULL) {
                        /*
                         * This much to be malloc'd:
                         *   strlen(*envp) + 1 char for 'L' +
                         *   MAXARGSWIDTH + 1 char for '=' + 1 for null char;
                         *
                         * total = strlen(*envp) + MAXARGSWIDTH + 3
                         */
                        int total = strlen(*envp) + MAXARGSWIDTH + 3;
                        envinit[basicenv+k] = malloc(total);
                        if (envinit[basicenv+k] == NULL) {
                                (void) printf("%s: malloc failed\n", PROG_NAME);
                                login_exit(1);
                        }
                        (void) snprintf(envinit[basicenv+k], total, "L%d=%s",
                            l_index, *envp);

                        k++;
                        l_index++;
                } else  {
                        if (!legalenvvar(*envp)) { /* this env var permited? */
                                continue;
                        } else {

                                /*
                                 * Check to see whether this string replaces
                                 * any previously defined string
                                 */
                                for (i = 0, length = endptr + 1 - *envp;
                                    i < basicenv + k; i++) {
                                        if (strncmp(*envp, envinit[i], length)
                                            == 0) {
                                                envinit[i] = *envp;
                                                break;
                                        }
                                }

                                /*
                                 * If it doesn't, place it at the end of
                                 * environment array.
                                 */
                                if (i == basicenv+k) {
                                        envinit[basicenv+k] = *envp;
                                        k++;
                                }
                        }
                }
        }               /* for (j = 0 ... ) */

switch_env:
        /*
         * Switch to the new environment.
         */
        environ = envinit;
}

/*
 * print_banner         - Print the banner at start up
 *                         Do not turn on DOBANNER ifdef.  This is not
 *                         relevant to SunOS.
 */

static void
print_banner(void)
{
#ifdef DOBANNER
        uname(&un);
#if i386
        (void) printf("UNIX System V/386 Release %s\n%s\n"
            "Copyright (C) 1984, 1986, 1987, 1988 AT&T\n"
            "Copyright (C) 1987, 1988 Microsoft Corp.\nAll Rights Reserved\n",
            un.release, un.nodename);
#elif sun
        (void) printf("SunOS Release %s Sun Microsystems %s\n%s\n"
            "Copyright (c) 1984, 1986, 1987, 1988 AT&T\n"
            "Copyright (c) 1988, 1989, 1990, 1991 Sun Microsystems\n"
            "All Rights Reserved\n",
            un.release, un.machine, un.nodename);
#else
        (void) printf("UNIX System V Release %s AT&T %s\n%s\n"
            "Copyright (c) 1984, 1986, 1987, 1988 AT&T\nAll Rights Reserved\n",
            un.release, un.machine, un.nodename);
#endif /* i386 */
#endif /* DOBANNER */
}

/*
 * display_last_login_time      - Advise the user the time and date
 *                                that this login-id was last used.
 */

static void
display_last_login_time(void)
{
        if (lastlogok) {
                (void) printf("Last login: %.*s ", 24-5, ctime(&ll.ll_time));

                if (*ll.ll_host != '\0')
                        (void) printf("from %.*s\n", sizeof (ll.ll_host),
                            ll.ll_host);
                else
                        (void) printf("on %.*s\n", sizeof (ll.ll_line),
                            ll.ll_line);
        }
}

/*
 * exec_the_shell       - invoke the specified shell or start up program
 */

static void
exec_the_shell(void)
{
        char *endptr;
        int i;

        (void) strlcat(minusnam, basename(pwd->pw_shell),
            sizeof (minusnam));

        /*
         * Exec the shell
         */
        (void) execl(pwd->pw_shell, minusnam, (char *)0);

        /*
         * pwd->pw_shell was not an executable object file, maybe it
         * is a shell proceedure or a command line with arguments.
         * If so, turn off the SHELL= environment variable.
         */
        for (i = 0; envinit[i] != NULL; ++i) {
                if ((envinit[i] == shell) &&
                    ((endptr = strchr(shell, '=')) != NULL))
                        (*++endptr) = '\0';
                }

        if (access(pwd->pw_shell, R_OK|X_OK) == 0) {
                (void) execl(SHELL, "sh", pwd->pw_shell, (char *)0);
                (void) execl(SHELL2, "sh", pwd->pw_shell, (char *)0);
        }

        (void) printf("No shell\n");
}

/*
 * login_exit           - Call exit()  and terminate.
 *                        This function is here for PAM so cleanup can
 *                        be done before the process exits.
 */
static void
login_exit(int exit_code)
{
        if (pamh)
                (void) pam_end(pamh, PAM_ABORT);

        if (audit_error)
                audit_failure(get_audit_id(), audit_error,
                    pwd, remote_host, ttyn, zone_name);

        exit(exit_code);
        /*NOTREACHED*/
}

/*
 * Check if lenv and penv matches or not.
 */
static int
locale_envmatch(char *lenv, char *penv)
{
        while ((*lenv == *penv) && *lenv && *penv != '=') {
                lenv++;
                penv++;
        }

        /*
         * '/' is eliminated for security reason.
         */
        if (*lenv == '\0' && *penv == '=' && *(penv + 1) != '/')
                return (1);
        return (0);
}

static int
is_number(char *ptr)
{
        while (*ptr != '\0') {
                if (!isdigit(*ptr))
                        return (0);
                ptr++;
        }
        return (1);
}