/*
 * 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 2010 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   */

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

/*
 * passwd is a program whose sole purpose is to manage
 * the password file, map, or table. It allows system administrator
 * to add, change and display password attributes.
 * Non privileged user can change password or display
 * password attributes which corresponds to their login name.
 */

#include <stdio.h>
#include <pwd.h>
#include <sys/types.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <locale.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
#include <security/pam_appl.h>
#include <security/pam_modules.h>
#include <security/pam_impl.h>
#include <rpcsvc/nis.h>
#undef GROUP
#include <syslog.h>
#include <userdefs.h>
#include <passwdutil.h>

#include <nss_dbdefs.h>

#include <deflt.h>

#undef  GROUP
#include <bsm/adt.h>
#include <bsm/adt_event.h>

/*
 * flags indicate password attributes to be modified
 */

#define LFLAG 0x001             /* lock user's password  */
#define DFLAG 0x002             /* delete user's  password */
#define MFLAG 0x004             /* set max field -- # of days passwd is valid */
#define NFLAG 0x008             /* set min field -- # of days between */
                                /* password changes */
#define SFLAG 0x010             /* display password attributes */
#define FFLAG 0x020             /* expire  user's password */
#define AFLAG 0x040             /* display password attributes for all users */
#define SAFLAG (SFLAG|AFLAG)    /* display password attributes for all users */
#define WFLAG 0x100             /* warn user to change passwd */
#define OFLAG 0x200             /* domain name */
#define EFLAG 0x400             /* change shell */
#define GFLAG 0x800             /* change gecos information */
#define HFLAG 0x1000            /* change home directory */
#define XFLAG 0x2000            /* no login */
#define UFLAG 0x4000            /* unlock user's password */

#define NONAGEFLAG      (EFLAG | GFLAG | HFLAG)
#define AGEFLAG (LFLAG | FFLAG | MFLAG | NFLAG | WFLAG | XFLAG | UFLAG)
#define MUTEXFLAG       (DFLAG | LFLAG | XFLAG | UFLAG | SAFLAG)


/*
 * exit code
 */

#define SUCCESS 0       /* succeeded */
#define NOPERM  1       /* No permission */
#define BADOPT  2       /* Invalid combination of option */
#define FMERR   3       /* File/table manipulation error */
#define FATAL   4       /* Old file/table can not be recovered */
#define FBUSY   5       /* Lock file/table busy */
#define BADSYN  6       /* Incorrect syntax */
#define BADAGE  7       /* Aging is disabled  */
#define NOMEM   8       /* No memory */
#define SYSERR  9       /* System error */
#define EXPIRED 10      /* Account expired */

/*
 * define error messages
 */
#define MSG_NP          "Permission denied"
#define MSG_BS          "Invalid combination of options"
#define MSG_FE          "Unexpected failure. Password file/table unchanged."
#define MSG_FF          "Unexpected failure. Password file/table missing."
#define MSG_FB          "Password file/table busy. Try again later."
#define MSG_NV          "Invalid argument to option"
#define MSG_AD          "Password aging is disabled"
#define MSG_RS          "Cannot change from restricted shell %s\n"
#define MSG_NM          "Out of memory."
#define MSG_UNACCEPT    "%s is unacceptable as a new shell\n"
#define MSG_UNAVAIL     "warning: %s is unavailable on this machine\n"
#define MSG_COLON       "':' is not allowed.\n"
#define MSG_MAXLEN      "Maximum number of characters allowed is %d."
#define MSG_CONTROL     "Control characters are not allowed.\n"
#define MSG_SHELL_UNCHANGED     "Login shell unchanged.\n"
#define MSG_GECOS_UNCHANGED     "Finger information unchanged.\n"
#define MSG_DIR_UNCHANGED       "Homedir information unchanged.\n"
#define MSG_NAME        "\nName [%s]: "
#define MSG_HOMEDIR     "\nHome Directory [%s]: "
#define MSG_OLDSHELL    "Old shell: %s\n"
#define MSG_NEWSHELL    "New shell: "
#define MSG_AGAIN       "\nPlease try again\n"
#define MSG_INPUTHDR    "Default values are printed inside of '[]'.\n" \
                        "To accept the default, type <return>.\n" \
                        "To have a blank entry, type the word 'none'.\n"
#define MSG_UNKNOWN     "%s: User unknown: %s\n"
#define MSG_ACCOUNT_EXP "User account has expired: %s\n"
#define MSG_AUTHTOK_EXP "Your password has been expired for too long.\n" \
                        "Please contact the system administrator.\n"
#define MSG_NIS_HOMEDIR "-h does not apply to NIS"
#define MSG_CUR_PASS    "Enter existing login password: "
#define MSG_CUR_PASS_UNAME      "Enter %s's existing login password: "
#define MSG_SUCCESS     "%s: password information changed for %s\n"
#define MSG_SORRY       "%s: Sorry, wrong passwd\n"
#define MSG_INFO        "%s: Changing password for %s\n"


/*
 * return code from ckarg() routine
 */
#define FAIL            -1

/*
 *  defind password file name
 */
#define PASSWD                  "/etc/passwd"

#define MAX_INPUT_LEN           512

#define DEF_ATTEMPTS    3

/* Number of characters in that make up an encrypted password (for now) */
#define NUMCP                   13

#ifdef DEBUG
#define dprintf1        printf
#else
#define dprintf1(w, x)
#endif

extern int      optind;

static int              retval = SUCCESS;
static int              pam_retval = PAM_SUCCESS;
static uid_t            uid;
static char             *prognamep;
static long             maxdate;        /* password aging information */
static int              passwd_conv(int, const struct pam_message **,
                            struct pam_response **, void *);
static struct pam_conv  pam_conv = {passwd_conv, NULL};
static pam_handle_t     *pamh;          /* Authentication handle */
static char             *usrname;       /* user whose attribute we update */
static adt_session_data_t *ah;  /* audit session handle */
static adt_event_data_t *event = NULL; /* event to be generated */

static pam_repository_t auth_rep;
static pwu_repository_t repository;
static pwu_repository_t __REPFILES = { "files", NULL, 0 };

/*
 * Function Declarations
 */

extern  void            setusershell(void);
extern  char            *getusershell(void);
extern  void            endusershell(void);

static  void            passwd_exit(int retcode) __NORETURN;
static  void            rusage(void);
static  int             ckuid(void);
static  int             ckarg(int argc, char **argv, attrlist **attributes);

static  int             get_namelist(pwu_repository_t, char ***, int *);
static  int             get_namelist_files(char ***, int *);
static  int             get_namelist_local(char ***, int *);
static  int             get_attr(char *, pwu_repository_t *, attrlist **);
static  void            display_attr(char *, attrlist *);
static  void            free_attr(attrlist *);
static  void            attrlist_add(attrlist **, attrtype, char *);
static  void            attrlist_reorder(attrlist **);
static  char            *userinput(char *, pwu_repository_t *, attrtype);
static  char            *getresponse(char *);

/*
 * main():
 *      The main routine will call ckarg() to parse the command line
 *      arguments and call the appropriate functions to perform the
 *      tasks specified by the arguments. It allows system
 *      administrator to add, change and display password attributes.
 *      Non privileged user can change password or display
 *      password attributes which corresponds to their login name.
 */

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

        int     flag;
        char    **namelist;
        int     num_user;
        int     i;
        attrlist *attributes = NULL;
        char    *input;
        int     tries = 1;
        int     updated_reps;


        if ((prognamep = strrchr(argv[0], '/')) != NULL)
                ++prognamep;
        else
                prognamep = argv[0];

        auth_rep.type = NULL;
        auth_rep.scope = NULL;
        repository.type = NULL;
        repository.scope = NULL;
        repository.scope_len = 0;


        /* initialization for variables, set locale and textdomain  */
        i = 0;
        flag = 0;

        uid = getuid();         /* get the user id */
        (void) setlocale(LC_ALL, "");

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

        /*
         * ckarg() parses the arguments. In case of an error,
         * it sets the retval and returns FAIL (-1).
         */

        flag = ckarg(argc, argv, &attributes);
        dprintf1("flag is %0x\n", flag);
        if (flag == FAIL)
                passwd_exit(retval);

        argc -= optind;

        if (argc < 1) {
                if ((usrname = getlogin()) == NULL) {
                        struct passwd *pass = getpwuid(uid);
                        if (pass != NULL)
                                usrname = pass->pw_name;
                        else {
                                rusage();
                                exit(NOPERM);
                        }
                } else if (flag == 0) {
                        /*
                         * If flag is zero, change passwd.
                         * Otherwise, it will display or
                         * modify password aging attributes
                         */
                        (void) fprintf(stderr, gettext(MSG_INFO), prognamep,
                            usrname);
                }
        } else {
                usrname = argv[optind];
        }

        if (pam_start("passwd", usrname, &pam_conv, &pamh) != PAM_SUCCESS) {
                passwd_exit(NOPERM);
        }

        auth_rep.type = repository.type;
        auth_rep.scope = repository.scope;
        auth_rep.scope_len = repository.scope_len;

        if (auth_rep.type != NULL) {
                if (pam_set_item(pamh, PAM_REPOSITORY, (void *)&auth_rep)
                    != PAM_SUCCESS) {
                        passwd_exit(NOPERM);
                }
        }

        if (flag ==  SAFLAG) {  /* display password attributes for all users */
                retval = get_namelist(repository, &namelist, &num_user);
                if (retval != SUCCESS)
                        (void) passwd_exit(retval);

                if (num_user == 0) {
                        (void) fprintf(stderr, "%s: %s\n", prognamep,
                            gettext(MSG_FF));
                        passwd_exit(FATAL);
                }
                i = 0;
                while (namelist[i] != NULL) {
                        (void) get_attr(namelist[i], &repository,
                            &attributes);
                        (void) display_attr(namelist[i], attributes);
                        (void) free(namelist[i]);
                        (void) free_attr(attributes);
                        i++;
                }
                (void) free(namelist);
                passwd_exit(SUCCESS);
        } else if (flag == SFLAG) { /* display password attributes by user */
                if (get_attr(usrname, &repository, &attributes) ==
                    PWU_SUCCESS) {
                        (void) display_attr(usrname, attributes);
                        (void) free_attr(attributes);
                }
                passwd_exit(SUCCESS);
                /* NOT REACHED */
        }


        switch (pam_authenticate(pamh, 0)) {
        case PAM_SUCCESS:
                break;
        case PAM_USER_UNKNOWN:
                (void) fprintf(stderr, gettext(MSG_UNKNOWN), prognamep,
                    usrname);
                passwd_exit(NOPERM);
                break;
        case PAM_PERM_DENIED:
                passwd_exit(NOPERM);
                break;
        case PAM_AUTH_ERR:
                (void) fprintf(stderr, gettext(MSG_SORRY), prognamep);
                passwd_exit(NOPERM);
                break;
        default:
                /* system error */
                passwd_exit(FMERR);
                break;
        }

        if (flag == 0) {                        /* changing user password */
                int     chk_authtok = 0;        /* check password strength */

                dprintf1("call pam_chauthtok() repository name =%s\n",
                    repository.type);

                /* Set up for Audit */
                if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA) != 0) {
                        perror("adt_start_session");
                        passwd_exit(SYSERR);
                }
                if ((event = adt_alloc_event(ah, ADT_passwd)) == NULL) {
                        perror("adt_alloc_event");
                        passwd_exit(NOMEM);
                }

                /* Don't check account expiration when invoked by root */
                if (ckuid() != SUCCESS) {
                        pam_retval = pam_acct_mgmt(pamh, PAM_SILENT);
                        switch (pam_retval) {
                        case PAM_ACCT_EXPIRED:
                                (void) fprintf(stderr,
                                    gettext(MSG_ACCOUNT_EXP), usrname);
                                passwd_exit(EXPIRED);
                                break;
                        case PAM_AUTHTOK_EXPIRED:
                                (void) fprintf(stderr,
                                    gettext(MSG_AUTHTOK_EXP));
                                passwd_exit(NOPERM);
                                break;
                        case PAM_NEW_AUTHTOK_REQD:
                                /* valid error when changing passwords */
                                break;
                        case PAM_SUCCESS:
                                /* Ok to change password */
                                break;
                        default:
                                passwd_exit(NOPERM);
                        }
                }


                pam_retval = PAM_AUTHTOK_ERR;
                tries = 1;
                if (ckuid() == SUCCESS) {
                        /* bypass password strength checks */
                        chk_authtok = PAM_NO_AUTHTOK_CHECK;
                }

                while (pam_retval == PAM_AUTHTOK_ERR && tries <= DEF_ATTEMPTS) {
                        if (tries > 1)
                                (void) printf(gettext(MSG_AGAIN));
                        pam_retval = pam_chauthtok(pamh, chk_authtok);
                        if (pam_retval == PAM_TRY_AGAIN) {
                                (void) sleep(1);
                                pam_retval = pam_chauthtok(pamh, chk_authtok);
                        }
                        tries++;
                }

                switch (pam_retval) {
                case PAM_SUCCESS:
                        retval = SUCCESS;
                        break;
                case PAM_AUTHTOK_DISABLE_AGING:
                        retval = BADAGE;
                        break;
                case PAM_AUTHTOK_LOCK_BUSY:
                        retval = FBUSY;
                        break;
                case PAM_TRY_AGAIN:
                        retval = FBUSY;
                        break;
                case PAM_AUTHTOK_ERR:
                case PAM_AUTHTOK_RECOVERY_ERR:
                default:
                        retval = NOPERM;
                        break;
                }

                (void) passwd_exit(retval);
                /* NOT REACHED */
        } else {                /* changing attributes */
                switch (flag) {
                case EFLAG:             /* changing user password attributes */
                        input = userinput(usrname, &repository, ATTR_SHELL);
                        if (input)
                                attrlist_add(&attributes, ATTR_SHELL, input);
                        else
                                (void) printf(gettext(MSG_SHELL_UNCHANGED));
                        break;
                case GFLAG:
                        input = userinput(usrname, &repository, ATTR_GECOS);
                        if (input)
                                attrlist_add(&attributes, ATTR_GECOS, input);
                        else
                                (void) printf(gettext(MSG_GECOS_UNCHANGED));
                        break;
                case HFLAG:
                        input = userinput(usrname, &repository, ATTR_HOMEDIR);
                        if (input)
                                attrlist_add(&attributes, ATTR_HOMEDIR, input);
                        else
                                (void) printf(gettext(MSG_DIR_UNCHANGED));
                        break;
                }

                if (attributes != NULL) {
                        retval = __set_authtoken_attr(usrname,
                            pamh->ps_item[PAM_AUTHTOK].pi_addr,
                            &repository, attributes, &updated_reps);
                        switch (retval) {
                        case PWU_SUCCESS:
                                for (i = 1; i <= REP_LAST; i <<= 1) {
                                        if ((updated_reps & i) == 0)
                                                continue;
                                        (void) printf(gettext(MSG_SUCCESS),
                                            prognamep, usrname);
                                }
                                retval = SUCCESS;
                                break;
                        case PWU_AGING_DISABLED:
                                retval = BADAGE;
                                break;
                        default:
                                retval = NOPERM;
                                break;
                        }
                } else {
                        retval = SUCCESS; /* nothing to change won't fail */
                }
                (void) passwd_exit(retval);
        }
        /* NOTREACHED */
        return (0);
}

/*
 * Get a line of input from the user.
 *
 * If the line is empty, or the input equals 'oldval', NULL is returned.
 * therwise, a malloced string containing the input (minus the trailing
 * newline) is returned.
 */
char *
getresponse(char *oldval)
{
        char    resp[MAX_INPUT_LEN];
        char    *retval = NULL;
        int     resplen;

        (void) fgets(resp, sizeof (resp) - 1, stdin);
        resplen = strlen(resp) - 1;
        if (resp[resplen] == '\n')
                resp[resplen] = '\0';
        if (*resp != '\0' && strcmp(resp, oldval) != 0)
                retval = strdup(resp);
        return (retval);
}

/*
 * char *userinput(item)
 *
 * user conversation function. The old value of attribute "item" is
 * displayed while the user is asked to provide a new value.
 *
 * returns a malloc()-ed string if the user actualy provided input
 * or NULL if the user simply hit return or the input equals the old
 * value (not changed).
 */
char *
userinput(char *name, pwu_repository_t *rep, attrtype type)
{
        attrlist oldattr;
        char *oldval;                   /* shorthand for oldattr.data.val_s */
        char *valid;                    /* points to valid shells */
        char *response;
        char *cp;

        oldattr.type = type;
        oldattr.next = NULL;

        if (__get_authtoken_attr(name, rep, &oldattr) != PWU_SUCCESS)
                passwd_exit(FMERR);

        oldval = oldattr.data.val_s;

        if (type == ATTR_SHELL) {
                /* No current shell: set DEFSHL as default choice */
                if (*oldval == '\0') {
                        free(oldval);
                        oldval = strdup(DEFSHL);
                }

                if (ckuid() != SUCCESS) {
                        /* User must currently have a valid shell */
                        setusershell();
                        valid = getusershell();
                        while (valid && strcmp(valid, oldval) != 0)
                                valid = getusershell();
                        endusershell();

                        if (valid == NULL) {
                                (void) fprintf(stderr, gettext(MSG_RS), oldval);
                                free(oldval);
                                return (NULL);
                        }
                }
                (void) printf(gettext(MSG_OLDSHELL), oldval);
                (void) printf(gettext(MSG_NEWSHELL));
                (void) fflush(stdout);

                response = getresponse(oldval);
                free(oldval); /* We don't need the old value anymore */

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

                /* Make sure new shell is listed */
                setusershell();
                valid = getusershell();
                while (valid) {
                        char *cp;

                        /* Allow user to give shell without path */
                        if (*response == '/') {
                                cp = valid;
                        } else {
                                if ((cp = strrchr(valid, '/')) == NULL)
                                        cp = valid;
                                else
                                        cp++;
                        }
                        if (strcmp(cp, response) == 0) {
                                if (*response != '/') {
                                        /* take shell name including path */
                                        free(response);
                                        response = strdup(valid);
                                }
                                break;
                        }
                        valid = getusershell();
                }
                endusershell();

                if (valid == NULL) {    /* No valid shell matches */
                        (void) fprintf(stderr, gettext(MSG_UNACCEPT), response);
                        return (NULL);
                }

                if (access(response, X_OK) < 0)
                        (void) fprintf(stderr, gettext(MSG_UNAVAIL), response);
                return (response);
                /* NOT REACHED */
        }
        /*
         * if type == SHELL, we have returned by now. Only GECOS and
         * HOMEDIR get to this point.
         */
        (void) printf(gettext(MSG_INPUTHDR));

        /*
         * PRE: oldval points to malloced string with Old Value
         * INV: oldval remains unchanged
         * POST:response points to valid string or NULL.
         */
        for (;;) {
                if (type == ATTR_GECOS)
                        (void) printf(gettext(MSG_NAME), oldval);
                else if (type == ATTR_HOMEDIR)
                        (void) printf(gettext(MSG_HOMEDIR), oldval);

                response = getresponse(oldval);

                if (response && strcmp(response, "none") == 0)
                        *response = '\0';

                /* No-change or empty string are OK */
                if (response == NULL || *response == '\0')
                        break;

                /* Check for illegal characters */
                if (strchr(response, ':')) {
                        (void) fprintf(stderr, "%s", gettext(MSG_COLON));
                        free(response);
                } else if (strlen(response) > MAX_INPUT_LEN - 1) {
                        (void) fprintf(stderr, gettext(MSG_MAXLEN),
                            MAX_INPUT_LEN);
                        free(response);
                } else {
                        /* don't allow control characters */
                        for (cp = response; *cp >= 040; cp++)
                                ;
                        if (*cp != '\0') {
                                (void) fprintf(stderr, gettext(MSG_CONTROL));
                                free(response);
                        } else
                                break;  /* response is a valid string */
                }
                /*
                 * We only get here if the input was invalid.
                 * In that case, we again ask the user for input.
                 */
        }
        free(oldval);
        return (response);
}
/*
 * ckarg():
 *      This function parses and verifies the
 *      arguments.  It takes three parameters:
 *      argc => # of arguments
 *      argv => pointer to an argument
 *      attrlist => pointer to list of password attributes
 */

static int
ckarg(int argc, char **argv, attrlist **attributes)
{
        extern char     *optarg;
        char            *char_p;
        int     opt;
        int     flag;

        flag = 0;

        while ((opt = getopt(argc, argv, "r:aldefghsux:n:w:N")) != EOF) {
                switch (opt) {

                case 'r': /* Repository Specified */
                        /* repository: this option should be specified first */

                        if (repository.type != NULL) {
                                (void) fprintf(stderr, gettext(
                        "Repository is already defined or specified.\n"));
                                rusage();
                                retval = BADSYN;
                                return (FAIL);
                        }
                        if (strcmp(optarg, "nis") == 0) {
                                repository.type = optarg;
                        } else if (strcmp(optarg, "ldap") == 0) {
                                repository.type = optarg;
                        } else if (strcmp(optarg, "files") == 0) {
                                repository.type = optarg;
                        } else {
                                (void) fprintf(stderr,
                                    gettext("invalid repository: %s\n"),
                                    optarg);
                                rusage();
                                retval = BADSYN;
                                return (FAIL);
                        }
                        break;

                case 'd': /* Delete Auth Token */
                        /* if no repository the default for -d is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        /*
                         * Delete the password - only privileged processes
                         * can execute this for FILES or LDAP
                         */
                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-d only applies to files "
                                    "or ldap repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        if (ckuid() != SUCCESS) {
                                retval = NOPERM;
                                return (FAIL);
                        }
                        if (flag & (LFLAG|SAFLAG|DFLAG|XFLAG|UFLAG)) {
                                rusage();
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= DFLAG;
                        attrlist_add(attributes, ATTR_PASSWD, NULL);
                        break;

                case 'N': /* set account to be "no login" */

                        /* if no repository the default for -N is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-N only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADOPT;
                                return (FAIL);
                        }

                        /*
                         * Only privileged processes can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag & (MUTEXFLAG|NONAGEFLAG)) {
                                rusage();       /* exit */
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= XFLAG;
                        attrlist_add(attributes, ATTR_NOLOGIN_ACCOUNT, NULL);
                        break;

                case 'l': /* lock the password */

                        /* if no repository the default for -l is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-l only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADOPT;
                                return (FAIL);
                        }

                        /*
                         * Only privileged processes can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag & (MUTEXFLAG|NONAGEFLAG)) {
                                rusage();       /* exit */
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= LFLAG;
                        attrlist_add(attributes, ATTR_LOCK_ACCOUNT, NULL);
                        break;

                case 'u': /* unlock the password */

                        /* if no repository the default for -u is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-u only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADOPT;
                                return (FAIL);
                        }

                        /*
                         * Only privileged processes can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag & (MUTEXFLAG|NONAGEFLAG)) {
                                rusage();       /* exit */
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= UFLAG;
                        attrlist_add(attributes, ATTR_UNLOCK_ACCOUNT, NULL);
                        attrlist_add(attributes, ATTR_RST_FAILED_LOGINS, NULL);
                        break;

                case 'x': /* set the max date */

                        /* if no repository the default for -x is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-x only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        /*
                         * Only privileged process can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            (ckuid() != SUCCESS)) {
                                retval = NOPERM;
                                return (FAIL);
                        }
                        if (flag & (SAFLAG|MFLAG|NONAGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= MFLAG;
                        if ((int)strlen(optarg)  <= 0 ||
                            (maxdate = strtol(optarg, &char_p, 10)) < -1 ||
                            *char_p != '\0') {
                                (void) fprintf(stderr, "%s: %s -x\n",
                                    prognamep, gettext(MSG_NV));
                                retval = BADSYN;
                                return (FAIL);
                        }
                        attrlist_add(attributes, ATTR_MAX, optarg);
                        break;

                case 'n': /* set the min date */

                        /* if no repository the default for -n is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-n only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        /*
                         * Only privileged process can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag & (SAFLAG|NFLAG|NONAGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= NFLAG;
                        if ((int)strlen(optarg)  <= 0 ||
                            (strtol(optarg, &char_p, 10)) < 0 ||
                            *char_p != '\0') {
                                (void) fprintf(stderr, "%s: %s -n\n",
                                    prognamep, gettext(MSG_NV));
                                retval = BADSYN;
                                return (FAIL);
                        }
                        attrlist_add(attributes, ATTR_MIN, optarg);
                        break;

                case 'w': /* set the warning field */

                        /* if no repository the default for -w is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-w only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        /*
                         * Only privileged process can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            (ckuid() != SUCCESS)) {
                                retval = NOPERM;
                                return (FAIL);
                        }
                        if (flag & (SAFLAG|WFLAG|NONAGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= WFLAG;
                        if ((int)strlen(optarg)  <= 0 ||
                            (strtol(optarg, &char_p, 10)) < 0 ||
                            *char_p != '\0') {
                                (void) fprintf(stderr, "%s: %s -w\n",
                                    prognamep, gettext(MSG_NV));
                                retval = BADSYN;
                                return (FAIL);
                        }
                        attrlist_add(attributes, ATTR_WARN, optarg);
                        break;

                case 's': /* display password attributes */

                        /* if no repository the default for -s is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;


                        /* display password attributes */
                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-s only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        /*
                         * Only privileged process can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag && (flag != AFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= SFLAG;
                        break;

                case 'a': /* display password attributes */

                        /* if no repository the default for -a is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-a only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        /*
                         * Only privileged process can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag && (flag != SFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= AFLAG;
                        break;

                case 'f': /* expire password attributes */

                        /* if no repository the default for -f is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (IS_FILES(repository) == FALSE &&
                            IS_LDAP(repository) == FALSE) {
                                (void) fprintf(stderr, gettext(
                                    "-f only applies to files or ldap "
                                    "repository\n"));
                                rusage();       /* exit */
                                retval = BADSYN;
                                return (FAIL);
                        }

                        /*
                         * Only privileged process can execute this
                         * for FILES or LDAP
                         */
                        if ((IS_FILES(repository) || IS_LDAP(repository)) &&
                            ((retval = ckuid()) != SUCCESS))
                                return (FAIL);
                        if (flag & (SAFLAG|FFLAG|NONAGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= FFLAG;
                        attrlist_add(attributes, ATTR_EXPIRE_PASSWORD, NULL);
                        break;

                case 'e': /* change login shell */

                        /* if no repository the default for -e is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        if (flag & (EFLAG|SAFLAG|AGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= EFLAG;
                        break;

                case 'g': /* change gecos information */

                        /* if no repository the default for -g is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;

                        /*
                         * Only privileged process can execute this
                         * for FILES
                         */
                        if (IS_FILES(repository) && (ckuid() != SUCCESS)) {
                                retval = NOPERM;
                                return (FAIL);
                        }
                        if (flag & (GFLAG|SAFLAG|AGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= GFLAG;
                        break;

                case 'h': /* change home dir */

                        /* if no repository the default for -h is files */
                        if (repository.type == NULL)
                                repository = __REPFILES;
                        /*
                         * Only privileged process can execute this
                         * for FILES
                         */
                        if (IS_FILES(repository) && (ckuid() != SUCCESS)) {
                                retval = NOPERM;
                                return (FAIL);
                        }
                        if (IS_NIS(repository)) {
                                (void) fprintf(stderr, "%s\n",
                                    gettext(MSG_NIS_HOMEDIR));
                                retval = BADSYN;
                                return (FAIL);
                        }

                        if (flag & (HFLAG|SAFLAG|AGEFLAG)) {
                                retval = BADOPT;
                                return (FAIL);
                        }
                        flag |= HFLAG;
                        break;

                case '?':
                        rusage();
                        retval = BADOPT;
                        return (FAIL);
                }
        }

        argc -= optind;
        if (argc > 1) {
                rusage();
                retval = BADSYN;
                return (FAIL);
        }

        /* Make sure (EXPIRE comes after (MAX comes after MIN)) */
        attrlist_reorder(attributes);

        /* If no options are specified or only the show option */
        /* is specified, return because no option error checking */
        /* is needed */
        if (!flag || (flag == SFLAG))
                return (flag);

        /* AFLAG must be used with SFLAG */
        if (flag == AFLAG) {
                rusage();
                retval = BADSYN;
                return (FAIL);
        }

        if (flag != SAFLAG && argc < 1) {
                /*
                 * user name is not specified (argc<1), it can't be
                 * aging info update.
                 */
                if (!(flag & NONAGEFLAG)) {
                        rusage();
                        retval = BADSYN;
                        return (FAIL);
                }
        }

        /* user name(s) may not be specified when SAFLAG is used. */
        if (flag == SAFLAG && argc >= 1) {
                rusage();
                retval = BADSYN;
                return (FAIL);
        }

        /*
         * If aging is being turned off (maxdate == -1), mindate may not
         * be specified.
         */
        if ((maxdate == -1) && (flag & NFLAG)) {
                (void) fprintf(stderr, "%s: %s -n\n",
                    prognamep, gettext(MSG_NV));
                retval = BADOPT;
                return (FAIL);
        }

        return (flag);
}

/*
 *
 * ckuid():
 *      This function returns SUCCESS if the caller is root, else
 *      it returns NOPERM.
 *
 */

static int
ckuid(void)
{
        if (uid != 0) {
                return (retval = NOPERM);
        }
        return (SUCCESS);
}


/*
 * get_attr()
 */
int
get_attr(char *username, pwu_repository_t *repository, attrlist **attributes)
{
        int res;

        attrlist_add(attributes, ATTR_PASSWD, NULL);
        attrlist_add(attributes, ATTR_LSTCHG, "0");
        attrlist_add(attributes, ATTR_MIN, "0");
        attrlist_add(attributes, ATTR_MAX, "0");
        attrlist_add(attributes, ATTR_WARN, "0");

        res = __get_authtoken_attr(username, repository, *attributes);

        if (res == PWU_SUCCESS) {
                retval = SUCCESS;
                return (PWU_SUCCESS);
        }

        if (res == PWU_NOT_FOUND)
                (void) fprintf(stderr, gettext(MSG_UNKNOWN), prognamep,
                    username);

        retval = NOPERM;
        passwd_exit(retval);
        /*NOTREACHED*/
}

/*
 * display_attr():
 * This function prints out the password attributes of a usr
 * onto standand output.
 */
void
display_attr(char *usrname, attrlist *attributes)
{
        char    *status = NULL;
        char    *passwd;
        long    lstchg;
        int     min = 0, max = 0, warn = 0;

        while (attributes) {
                switch (attributes->type) {
                case ATTR_PASSWD:
                        passwd = attributes->data.val_s;
                        if (passwd == NULL || *passwd == '\0')
                                status = "NP  ";
                        else if (strncmp(passwd, LOCKSTRING,
                            sizeof (LOCKSTRING)-1) == 0)
                                status = "LK  ";
                        else if (strncmp(passwd, NOLOGINSTRING,
                            sizeof (NOLOGINSTRING)-1) == 0)
                                status = "NL  ";
                        else if ((strlen(passwd) == 13 && passwd[0] != '$') ||
                            passwd[0] == '$')
                                status = "PS  ";
                        else
                                status = "UN  ";
                        break;
                case ATTR_LSTCHG:
                        lstchg = attributes->data.val_i * DAY;
                        break;
                case ATTR_MIN:
                        min = attributes->data.val_i;
                        break;
                case ATTR_MAX:
                        max = attributes->data.val_i;
                        break;
                case ATTR_WARN:
                        warn = attributes->data.val_i;
                        break;
                default:
                        break;
                }
                attributes = attributes->next;
        }
        (void) fprintf(stdout, "%-8s  ", usrname);

        if (status)
                (void) fprintf(stdout, "%s  ", status);

        if (max != -1) {
                if (lstchg == 0) {
                        (void) fprintf(stdout, "00/00/00  ");
                } else {
                        struct tm *tmp;
                        tmp = gmtime(&lstchg);
                        (void) fprintf(stdout, "%.2d/%.2d/%.2d  ",
                            tmp->tm_mon + 1,
                            tmp->tm_mday,
                            tmp->tm_year % 100);
                }
                (void) fprintf(stdout, (min >= 0) ? "%4d  " : "      ", min);
                (void) fprintf(stdout, "%4d  ", max);
                (void) fprintf(stdout, (warn > 0) ? "%4d  " : "      ", warn);
        }
        (void) fprintf(stdout, "\n");
}

void
free_attr(attrlist *attributes)
{
        while (attributes) {
                if (attributes->type == ATTR_PASSWD)
                        free(attributes->data.val_s);
                attributes = attributes->next;
        }
}

/*
 *
 * get_namelist_files():
 *      This function gets a list of user names on the system from
 *      the /etc/passwd file.
 *
 */
int
get_namelist_files(char ***namelist_p, int *num_user)
{
        FILE            *pwfp;
        struct passwd   *pwd;
        int             max_user;
        int             nuser;
        char    **nl;

        nuser = 0;
        errno = 0;
        pwd = NULL;

        if ((pwfp = fopen(PASSWD, "r")) == NULL)
                return (NOPERM);

        /*
         * find out the actual number of entries in the PASSWD file
         */
        max_user = 1;                   /* need one slot for terminator NULL */
        while ((pwd = fgetpwent(pwfp)) != NULL)
                max_user++;

        /*
         *      reset the file stream pointer
         */
        rewind(pwfp);

        nl = (char **)calloc(max_user, (sizeof (char *)));
        if (nl == NULL) {
                (void) fclose(pwfp);
                return (FMERR);
        }

        while ((pwd = fgetpwent(pwfp)) != NULL) {
                if ((nl[nuser] = strdup(pwd->pw_name)) == NULL) {
                        (void) fclose(pwfp);
                        return (FMERR);
                }
                nuser++;
        }

        nl[nuser] = NULL;
        *num_user = nuser;
        *namelist_p = nl;
        (void) fclose(pwfp);
        return (SUCCESS);
}

/*
 * get_namelist_local
 *
 */

/*
 * Our private version of the switch frontend for getspent.  We want
 * to search just the ldap sp file, so we want to bypass
 * normal nsswitch.conf based processing.  This implementation
 * compatible with version 2 of the name service switch.
 */
#define NSS_LDAP_ONLY           "ldap"

extern int str2spwd(const char *, int, void *, char *, int);

static DEFINE_NSS_DB_ROOT(db_root);
static DEFINE_NSS_GETENT(context);

static char *local_config;
static void
_lc_nss_initf_shadow(nss_db_params_t *p)
{
        p->name = NSS_DBNAM_SHADOW;
        p->config_name    = NSS_DBNAM_PASSWD;   /* Use config for "passwd" */
        p->default_config = local_config;       /* Use ldap only */
        p->flags = NSS_USE_DEFAULT_CONFIG;
}

static void
_lc_setspent(void)
{
        nss_setent(&db_root, _lc_nss_initf_shadow, &context);
}

static void
_lc_endspent(void)
{
        nss_endent(&db_root, _lc_nss_initf_shadow, &context);
        nss_delete(&db_root);
}

static struct spwd *
_lc_getspent_r(struct spwd *result, char *buffer, int buflen)
{
        nss_XbyY_args_t arg;
        char            *nam;

        /* In getXXent_r(), protect the unsuspecting caller from +/- entries */

        do {
                NSS_XbyY_INIT(&arg, result, buffer, buflen, str2spwd);
                        /* No key to fill in */
                (void) nss_getent(&db_root, _lc_nss_initf_shadow, &context,
                    &arg);
        } while (arg.returnval != 0 &&
            (nam = ((struct spwd *)arg.returnval)->sp_namp) != 0 &&
            (*nam == '+' || *nam == '-'));

        return (struct spwd *)NSS_XbyY_FINI(&arg);
}

static nss_XbyY_buf_t *buffer;

static struct spwd *
_lc_getspent(void)
{
        nss_XbyY_buf_t  *b;

        b = NSS_XbyY_ALLOC(&buffer, sizeof (struct spwd), NSS_BUFLEN_SHADOW);

        return (b == 0 ? 0 : _lc_getspent_r(b->result, b->buffer, b->buflen));
}

int
get_namelist_local(char ***namelist_p, int *num_user)
{
        int nuser = 0;
        int alloced = 100;
        char **nl;
        struct spwd *p;


        if ((nl = calloc(alloced, sizeof (*nl))) == NULL)
                return (FMERR);

        (void) _lc_setspent();
        while ((p = _lc_getspent()) != NULL) {
                if ((nl[nuser] = strdup(p->sp_namp)) == NULL) {
                        _lc_endspent();
                        return (FMERR);
                }
                if (++nuser == alloced) {
                        alloced += 100;
                        nl = realloc(nl, alloced * (sizeof (*nl)));
                        if (nl == NULL) {
                                _lc_endspent();
                                return (FMERR);
                        }
                }
        }
        (void) _lc_endspent();
        nl[nuser] = NULL;

        *namelist_p = nl;
        *num_user = nuser;              /* including NULL */

        return (SUCCESS);
}

int
get_namelist(pwu_repository_t repository, char ***namelist, int *num_user)
{
        if (IS_LDAP(repository)) {
                local_config = NSS_LDAP_ONLY;
                return (get_namelist_local(namelist, num_user));
        } else if (IS_FILES(repository))
                return (get_namelist_files(namelist, num_user));

        rusage();
        return (BADSYN);
}

/*
 *
 * passwd_exit():
 *      This function will call exit() with appropriate exit code
 *      according to the input "retcode" value.
 *      It also calls pam_end() to clean-up buffers before exit.
 *
 */

void
passwd_exit(int retcode)
{

        if (pamh)
                (void) pam_end(pamh, pam_retval);

        switch (retcode) {
        case SUCCESS:
                        break;
        case NOPERM:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_NP));
                        break;
        case BADOPT:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_BS));
                        break;
        case FMERR:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_FE));
                        break;
        case FATAL:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_FF));
                        break;
        case FBUSY:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_FB));
                        break;
        case BADSYN:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_NV));
                        break;
        case BADAGE:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_AD));
                        break;
        case NOMEM:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_NM));
                        break;
        default:
                        (void) fprintf(stderr, "%s\n", gettext(MSG_NP));
                        retcode = NOPERM;
                        break;
        }
        /* write password record */
        if (event != NULL) {
                struct passwd *pass;

                if ((pass = getpwnam(usrname)) == NULL) {
                        /* unlikely to ever get here, but ... */
                        event->adt_passwd.username = usrname;
                } else if (pass->pw_uid != uid) {
                        /* save target user */
                        event->adt_passwd.uid = pass->pw_uid;
                        event->adt_passwd.username = pass->pw_name;
                }

                if (adt_put_event(event,
                    retcode == SUCCESS ? ADT_SUCCESS : ADT_FAILURE,
                    retcode == SUCCESS ? ADT_SUCCESS : ADT_FAIL_PAM +
                    pam_retval) != 0) {
                        adt_free_event(event);
                        (void) adt_end_session(ah);
                        perror("adt_put_event");
                        exit(retcode);
                }
                adt_free_event(event);
        }
        (void) adt_end_session(ah);
        exit(retcode);
}

/*
 *
 * passwd_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
passwd_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 = (struct pam_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:
                        temp = getpassphrase(m->msg);
                        if (temp != NULL) {
                                r->resp = strdup(temp);
                                (void) memset(temp, 0, strlen(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 = (char *)calloc(PAM_MAX_RESP_SIZE,
                            sizeof (char));
                        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);
                        }
                        if (fgets(r->resp, PAM_MAX_RESP_SIZE-1, stdin)) {
                                int len = strlen(r->resp);
                                if (r->resp[len-1] == '\n')
                                        r->resp[len-1] = '\0';
                        }
                        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);
}

/*
 *              Utilities Functions
 */

/*
 * int attrlist_add(attrlist **l, attrtype type, char *val)
 * add an item, with type "type" and value "val", at the tail of list l.
 * This functions exits the application on OutOfMem error.
 */
void
attrlist_add(attrlist **l, attrtype type, char *val)
{
        attrlist **w;

        /* tail insert */
        for (w = l; *w != NULL; w = &(*w)->next)
                ;

        if ((*w = malloc(sizeof (**w))) == NULL)
                passwd_exit(NOMEM);

        (*w)->type = type;
        (*w)->next = NULL;

        switch (type) {
        case ATTR_MIN:
        case ATTR_WARN:
        case ATTR_MAX:
                (*w)->data.val_i = atoi(val);
                break;
        default:
                (*w)->data.val_s = val;
                break;
        }
}

/*
 * attrlist_reorder(attrlist **l)
 * Make sure that
 *      - if EXPIRE and MAX or MIN is set, EXPIRE comes after MAX/MIN
 *      - if both MIN and MAX are set, MAX comes before MIN.
 */

static void
attrlist_reorder(attrlist **l)
{
        attrlist        **w;
        attrlist        *exp = NULL;    /* ATTR_EXPIRE_PASSWORD, if found */
        attrlist        *max = NULL;    /* ATTR_MAX, if found */

        if (*l == NULL || (*l)->next == NULL)
                return;         /* order of list with <= one item is ok */

        /*
         * We simply walk the list, take off the EXPIRE and MAX items if
         * they appear, and put them (first MAX, them EXPIRE) at the end
         * of the list.
         */
        w = l;
        while (*w != NULL) {
                if ((*w)->type == ATTR_EXPIRE_PASSWORD) {
                        exp = *w;
                        *w = (*w)->next;
                } else if ((*w)->type == ATTR_MAX) {
                        max = *w;
                        *w = (*w)->next;
                } else
                        w = &(*w)->next;
        }

        /* 'w' points to the address of the 'next' field of the last element */

        if (max) {
                *w = max;
                w = &max->next;
        }
        if (exp) {
                *w = exp;
                w = &exp->next;
        }
        *w = NULL;
}

void
rusage(void)
{

#define MSG(a) (void) fprintf(stderr, gettext((a)));

        MSG("usage:\n");
        MSG("\tpasswd [-r files | -r nis | -r ldap] [name]\n");
        MSG("\tpasswd [-r files] [-egh] [name]\n");
        MSG("\tpasswd [-r files] -sa\n");
        MSG("\tpasswd [-r files] -s [name]\n");
        MSG("\tpasswd [-r files] [-d|-l|-N|-u] [-f] [-n min] [-w warn] "
            "[-x max] name\n");
        MSG("\tpasswd -r nis [-eg] [name]\n");
        MSG("\t\t[-x max] name\n");
        MSG("\tpasswd -r ldap [-egh] [name]\n");
        MSG("\tpasswd -r ldap -sa\n");
        MSG("\tpasswd -r ldap -s [name]\n");
        MSG("\tpasswd -r ldap [-l|-N|-u] [-f] [-n min] [-w warn] "
            "[-x max] name\n");
#undef MSG
}