Index: head/usr.sbin/pw/pw_conf.c
===================================================================
--- head/usr.sbin/pw/pw_conf.c	(revision 339533)
+++ head/usr.sbin/pw/pw_conf.c	(revision 339534)
@@ -1,545 +1,547 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
  * Copyright (C) 1996
  *	David L. Nugent.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY DAVID L. NUGENT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL DAVID L. NUGENT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #ifndef lint
 static const char rcsid[] =
   "$FreeBSD$";
 #endif /* not lint */
 
 #include <sys/types.h>
 #include <sys/sbuf.h>
 
 #include <err.h>
 #include <fcntl.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "pw.h"
 
 #define debugging 0
 
 enum {
 	_UC_NONE,
 	_UC_DEFAULTPWD,
 	_UC_REUSEUID,
 	_UC_REUSEGID,
 	_UC_NISPASSWD,
 	_UC_DOTDIR,
 	_UC_NEWMAIL,
 	_UC_LOGFILE,
 	_UC_HOMEROOT,
 	_UC_HOMEMODE,
 	_UC_SHELLPATH,
 	_UC_SHELLS,
 	_UC_DEFAULTSHELL,
 	_UC_DEFAULTGROUP,
 	_UC_EXTRAGROUPS,
 	_UC_DEFAULTCLASS,
 	_UC_MINUID,
 	_UC_MAXUID,
 	_UC_MINGID,
 	_UC_MAXGID,
 	_UC_EXPIRE,
 	_UC_PASSWORD,
 	_UC_FIELDS
 };
 
 static char     bourne_shell[] = "sh";
 
 static char    *system_shells[_UC_MAXSHELLS] =
 {
 	bourne_shell,
 	"csh",
 	"tcsh"
 };
 
 static char const *booltrue[] =
 {
 	"yes", "true", "1", "on", NULL
 };
 static char const *boolfalse[] =
 {
 	"no", "false", "0", "off", NULL
 };
 
 static struct userconf config =
 {
 	0,			/* Default password for new users? (nologin) */
 	0,			/* Reuse uids? */
 	0,			/* Reuse gids? */
 	NULL,			/* NIS version of the passwd file */
 	"/usr/share/skel",	/* Where to obtain skeleton files */
 	NULL,			/* Mail to send to new accounts */
 	"/var/log/userlog",	/* Where to log changes */
 	"/home",		/* Where to create home directory */
 	_DEF_DIRMODE,		/* Home directory perms, modified by umask */
 	"/bin",			/* Where shells are located */
 	system_shells,		/* List of shells (first is default) */
 	bourne_shell,		/* Default shell */
 	NULL,			/* Default group name */
 	NULL,			/* Default (additional) groups */
 	NULL,			/* Default login class */
 	1000, 32000,		/* Allowed range of uids */
 	1000, 32000,		/* Allowed range of gids */
 	0,			/* Days until account expires */
 	0			/* Days until password expires */
 };
 
 static char const *comments[_UC_FIELDS] =
 {
 	"#\n# pw.conf - user/group configuration defaults\n#\n",
 	"\n# Password for new users? no=nologin yes=loginid none=blank random=random\n",
 	"\n# Reuse gaps in uid sequence? (yes or no)\n",
 	"\n# Reuse gaps in gid sequence? (yes or no)\n",
 	"\n# Path to the NIS passwd file (blank or 'no' for none)\n",
 	"\n# Obtain default dotfiles from this directory\n",
 	"\n# Mail this file to new user (/etc/newuser.msg or no)\n",
 	"\n# Log add/change/remove information in this file\n",
 	"\n# Root directory in which $HOME directory is created\n",
 	"\n# Mode for the new $HOME directory, will be modified by umask\n",
 	"\n# Colon separated list of directories containing valid shells\n",
 	"\n# Comma separated list of available shells (without paths)\n",
 	"\n# Default shell (without path)\n",
 	"\n# Default group (leave blank for new group per user)\n",
 	"\n# Extra groups for new users\n",
 	"\n# Default login class for new users\n",
 	"\n# Range of valid default user ids\n",
 	NULL,
 	"\n# Range of valid default group ids\n",
 	NULL,
 	"\n# Days after which account expires (0=disabled)\n",
 	"\n# Days after which password expires (0=disabled)\n"
 };
 
 static char const *kwds[] =
 {
 	"",
 	"defaultpasswd",
 	"reuseuids",
 	"reusegids",
 	"nispasswd",
 	"skeleton",
 	"newmail",
 	"logfile",
 	"home",
 	"homemode",
 	"shellpath",
 	"shells",
 	"defaultshell",
 	"defaultgroup",
 	"extragroups",
 	"defaultclass",
 	"minuid",
 	"maxuid",
 	"mingid",
 	"maxgid",
 	"expire_days",
 	"password_days",
 	NULL
 };
 
 static char    *
 unquote(char const * str)
 {
 	if (str && (*str == '"' || *str == '\'')) {
 		char           *p = strchr(str + 1, *str);
 
 		if (p != NULL)
 			*p = '\0';
 		return (char *) (*++str ? str : NULL);
 	}
 	return (char *) str;
 }
 
 int
 boolean_val(char const * str, int dflt)
 {
 	if ((str = unquote(str)) != NULL) {
 		int             i;
 
 		for (i = 0; booltrue[i]; i++)
 			if (strcmp(str, booltrue[i]) == 0)
 				return 1;
 		for (i = 0; boolfalse[i]; i++)
 			if (strcmp(str, boolfalse[i]) == 0)
 				return 0;
 	}
 	return dflt;
 }
 
 int
 passwd_val(char const * str, int dflt)
 {
 	if ((str = unquote(str)) != NULL) {
 		int             i;
 
 		for (i = 0; booltrue[i]; i++)
 			if (strcmp(str, booltrue[i]) == 0)
 				return P_YES;
 		for (i = 0; boolfalse[i]; i++)
 			if (strcmp(str, boolfalse[i]) == 0)
 				return P_NO;
 
 		/*
 		 * Special cases for defaultpassword
 		 */
 		if (strcmp(str, "random") == 0)
 			return P_RANDOM;
 		if (strcmp(str, "none") == 0)
 			return P_NONE;
 
 		errx(1, "Invalid value for default password");
 	}
 	return dflt;
 }
 
 char const     *
 boolean_str(int val)
 {
-	if (val == -1)
-		return "random";
-	else if (val == -2)
-		return "none";
+	if (val == P_NO)
+		return (boolfalse[0]);
+	else if (val == P_RANDOM)
+		return ("random");
+	else if (val == P_NONE)
+		return ("none");
 	else
-		return val ? booltrue[0] : boolfalse[0];
+		return (booltrue[0]);
 }
 
 char           *
 newstr(char const * p)
 {
 	char	*q;
 
 	if ((p = unquote(p)) == NULL)
 		return (NULL);
 
 	if ((q = strdup(p)) == NULL)
 		err(1, "strdup()");
 
 	return (q);
 }
 
 struct userconf *
 read_userconfig(char const * file)
 {
 	FILE	*fp;
 	char	*buf, *p;
 	const char *errstr;
 	size_t	linecap;
 	ssize_t	linelen;
 
 	buf = NULL;
 	linecap = 0;
 
 	if ((fp = fopen(file, "r")) == NULL)
 		return (&config);
 
 	while ((linelen = getline(&buf, &linecap, fp)) > 0) {
 		if (*buf && (p = strtok(buf, " \t\r\n=")) != NULL && *p != '#') {
 			static char const toks[] = " \t\r\n,=";
 			char           *q = strtok(NULL, toks);
 			int             i = 0;
 			mode_t          *modeset;
 
 			while (i < _UC_FIELDS && strcmp(p, kwds[i]) != 0)
 				++i;
 #if debugging
 			if (i == _UC_FIELDS)
 				printf("Got unknown kwd `%s' val=`%s'\n", p, q ? q : "");
 			else
 				printf("Got kwd[%s]=%s\n", p, q);
 #endif
 			switch (i) {
 			case _UC_DEFAULTPWD:
 				config.default_password = passwd_val(q, 1);
 				break;
 			case _UC_REUSEUID:
 				config.reuse_uids = boolean_val(q, 0);
 				break;
 			case _UC_REUSEGID:
 				config.reuse_gids = boolean_val(q, 0);
 				break;
 			case _UC_NISPASSWD:
 				config.nispasswd = (q == NULL || !boolean_val(q, 1))
 					? NULL : newstr(q);
 				break;
 			case _UC_DOTDIR:
 				config.dotdir = (q == NULL || !boolean_val(q, 1))
 					? NULL : newstr(q);
 				break;
 				case _UC_NEWMAIL:
 				config.newmail = (q == NULL || !boolean_val(q, 1))
 					? NULL : newstr(q);
 				break;
 			case _UC_LOGFILE:
 				config.logfile = (q == NULL || !boolean_val(q, 1))
 					? NULL : newstr(q);
 				break;
 			case _UC_HOMEROOT:
 				config.home = (q == NULL || !boolean_val(q, 1))
 					? "/home" : newstr(q);
 				break;
 			case _UC_HOMEMODE:
 				modeset = setmode(q);
 				config.homemode = (q == NULL || !boolean_val(q, 1))
 					? _DEF_DIRMODE : getmode(modeset, _DEF_DIRMODE);
 				free(modeset);
 				break;
 			case _UC_SHELLPATH:
 				config.shelldir = (q == NULL || !boolean_val(q, 1))
 					? "/bin" : newstr(q);
 				break;
 			case _UC_SHELLS:
 				for (i = 0; i < _UC_MAXSHELLS && q != NULL; i++, q = strtok(NULL, toks))
 					system_shells[i] = newstr(q);
 				if (i > 0)
 					while (i < _UC_MAXSHELLS)
 						system_shells[i++] = NULL;
 				break;
 			case _UC_DEFAULTSHELL:
 				config.shell_default = (q == NULL || !boolean_val(q, 1))
 					? (char *) bourne_shell : newstr(q);
 				break;
 			case _UC_DEFAULTGROUP:
 				q = unquote(q);
 				config.default_group = (q == NULL || !boolean_val(q, 1) || GETGRNAM(q) == NULL)
 					? NULL : newstr(q);
 				break;
 			case _UC_EXTRAGROUPS:
 				while ((q = strtok(NULL, toks)) != NULL) {
 					if (config.groups == NULL)
 						config.groups = sl_init();
 					sl_add(config.groups, newstr(q));
 				}
 				break;
 			case _UC_DEFAULTCLASS:
 				config.default_class = (q == NULL || !boolean_val(q, 1))
 					? NULL : newstr(q);
 				break;
 			case _UC_MINUID:
 				if ((q = unquote(q)) != NULL) {
 					config.min_uid = strtounum(q, 0,
 					    UID_MAX, &errstr);
 					if (errstr)
 						warnx("Invalid min_uid: '%s';"
 						    " ignoring", q);
 				}
 				break;
 			case _UC_MAXUID:
 				if ((q = unquote(q)) != NULL) {
 					config.max_uid = strtounum(q, 0,
 					    UID_MAX, &errstr);
 					if (errstr)
 						warnx("Invalid max_uid: '%s';"
 						    " ignoring", q);
 				}
 				break;
 			case _UC_MINGID:
 				if ((q = unquote(q)) != NULL) {
 					config.min_gid = strtounum(q, 0,
 					    GID_MAX, &errstr);
 					if (errstr)
 						warnx("Invalid min_gid: '%s';"
 						    " ignoring", q);
 				}
 				break;
 			case _UC_MAXGID:
 				if ((q = unquote(q)) != NULL) {
 					config.max_gid = strtounum(q, 0,
 					    GID_MAX, &errstr);
 					if (errstr)
 						warnx("Invalid max_gid: '%s';"
 						    " ignoring", q);
 				}
 				break;
 			case _UC_EXPIRE:
 				if ((q = unquote(q)) != NULL) {
 					config.expire_days = strtonum(q, 0,
 					    INT_MAX, &errstr);
 					if (errstr)
 						warnx("Invalid expire days:"
 						    " '%s'; ignoring", q);
 				}
 				break;
 			case _UC_PASSWORD:
 				if ((q = unquote(q)) != NULL) {
 					config.password_days = strtonum(q, 0,
 					    INT_MAX, &errstr);
 					if (errstr)
 						warnx("Invalid password days:"
 						    " '%s'; ignoring", q);
 				}
 				break;
 			case _UC_FIELDS:
 			case _UC_NONE:
 				break;
 			}
 		}
 	}
 	free(buf);
 	fclose(fp);
 
 	return (&config);
 }
 
 
 int
 write_userconfig(struct userconf *cnf, const char *file)
 {
 	int             fd;
 	int             i, j;
 	struct sbuf	*buf;
 	FILE           *fp;
 	char		cfgfile[MAXPATHLEN];
 
 	if (file == NULL) {
 		snprintf(cfgfile, sizeof(cfgfile), "%s/" _PW_CONF,
 		    conf.etcpath);
 		file = cfgfile;
 	}
 
 	if ((fd = open(file, O_CREAT|O_RDWR|O_TRUNC|O_EXLOCK, 0644)) == -1)
 		return (0);
 
 	if ((fp = fdopen(fd, "w")) == NULL) {
 		close(fd);
 		return (0);
 	}
 			
 	buf = sbuf_new_auto();
 	for (i = _UC_NONE; i < _UC_FIELDS; i++) {
 		int             quote = 1;
 
 		sbuf_clear(buf);
 		switch (i) {
 		case _UC_DEFAULTPWD:
 			sbuf_cat(buf, boolean_str(cnf->default_password));
 			break;
 		case _UC_REUSEUID:
 			sbuf_cat(buf, boolean_str(cnf->reuse_uids));
 			break;
 		case _UC_REUSEGID:
 			sbuf_cat(buf, boolean_str(cnf->reuse_gids));
 			break;
 		case _UC_NISPASSWD:
 			sbuf_cat(buf, cnf->nispasswd ?  cnf->nispasswd : "");
 			quote = 0;
 			break;
 		case _UC_DOTDIR:
 			sbuf_cat(buf, cnf->dotdir ?  cnf->dotdir :
 			    boolean_str(0));
 			break;
 		case _UC_NEWMAIL:
 			sbuf_cat(buf, cnf->newmail ?  cnf->newmail :
 			    boolean_str(0));
 			break;
 		case _UC_LOGFILE:
 			sbuf_cat(buf, cnf->logfile ?  cnf->logfile :
 			    boolean_str(0));
 			break;
 		case _UC_HOMEROOT:
 			sbuf_cat(buf, cnf->home);
 			break;
 		case _UC_HOMEMODE:
 			sbuf_printf(buf, "%04o", cnf->homemode);
 			quote = 0;
 			break;
 		case _UC_SHELLPATH:
 			sbuf_cat(buf, cnf->shelldir);
 			break;
 		case _UC_SHELLS:
 			for (j = 0; j < _UC_MAXSHELLS &&
 			    system_shells[j] != NULL; j++)
 				sbuf_printf(buf, "%s\"%s\"", j ?
 				    "," : "", system_shells[j]);
 			quote = 0;
 			break;
 		case _UC_DEFAULTSHELL:
 			sbuf_cat(buf, cnf->shell_default ?
 			    cnf->shell_default : bourne_shell);
 			break;
 		case _UC_DEFAULTGROUP:
 			sbuf_cat(buf, cnf->default_group ?
 			    cnf->default_group : "");
 			break;
 		case _UC_EXTRAGROUPS:
 			for (j = 0; cnf->groups != NULL &&
 			    j < (int)cnf->groups->sl_cur; j++)
 				sbuf_printf(buf, "%s\"%s\"", j ?
 				    "," : "", cnf->groups->sl_str[j]);
 			quote = 0;
 			break;
 		case _UC_DEFAULTCLASS:
 			sbuf_cat(buf, cnf->default_class ?
 			    cnf->default_class : "");
 			break;
 		case _UC_MINUID:
 			sbuf_printf(buf, "%ju", (uintmax_t)cnf->min_uid);
 			quote = 0;
 			break;
 		case _UC_MAXUID:
 			sbuf_printf(buf, "%ju", (uintmax_t)cnf->max_uid);
 			quote = 0;
 			break;
 		case _UC_MINGID:
 			sbuf_printf(buf, "%ju", (uintmax_t)cnf->min_gid);
 			quote = 0;
 			break;
 		case _UC_MAXGID:
 			sbuf_printf(buf, "%ju", (uintmax_t)cnf->max_gid);
 			quote = 0;
 			break;
 		case _UC_EXPIRE:
 			sbuf_printf(buf, "%jd", (intmax_t)cnf->expire_days);
 			quote = 0;
 			break;
 		case _UC_PASSWORD:
 			sbuf_printf(buf, "%jd", (intmax_t)cnf->password_days);
 			quote = 0;
 			break;
 		case _UC_NONE:
 			break;
 		}
 		sbuf_finish(buf);
 
 		if (comments[i])
 			fputs(comments[i], fp);
 
 		if (*kwds[i]) {
 			if (quote)
 				fprintf(fp, "%s = \"%s\"\n", kwds[i],
 				    sbuf_data(buf));
 			else
 				fprintf(fp, "%s = %s\n", kwds[i], sbuf_data(buf));
 #if debugging
 			printf("WROTE: %s = %s\n", kwds[i], sbuf_data(buf));
 #endif
 		}
 	}
 	sbuf_delete(buf);
 	return (fclose(fp) != EOF);
 }
Index: head/usr.sbin/pw/tests/pw_useradd_test.sh
===================================================================
--- head/usr.sbin/pw/tests/pw_useradd_test.sh	(revision 339533)
+++ head/usr.sbin/pw/tests/pw_useradd_test.sh	(revision 339534)
@@ -1,475 +1,497 @@
 # $FreeBSD$
 
 # Import helper functions
 . $(atf_get_srcdir)/helper_functions.shin
 
 # Test add user
 atf_test_case user_add
 user_add_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd test
 	atf_check -s exit:0 -o match:"^test:.*" \
 		grep "^test:.*" $HOME/master.passwd
 }
 
 # Test add user with option -N
 atf_test_case user_add_noupdate
 user_add_noupdate_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 -o match:"^test:.*" ${PW} useradd test -N
 	atf_check -s exit:1 -o empty grep "^test:.*" $HOME/master.passwd
 }
 
 # Test add user with comments
 atf_test_case user_add_comments
 user_add_comments_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd test -c 'Test User,work!,123,user@example.com'
 	atf_check -s exit:0 -o match:'^test:.*:Test User,work!,123,user@example.com:' \
 		grep '^test:.*:Test User,work!,123,user@example.com:' $HOME/master.passwd
 }
 
 # Test add user with comments and option -N
 atf_test_case user_add_comments_noupdate
 user_add_comments_noupdate_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 -o match:"^test:.*:Test User,work,123,456:" \
 		${PW} useradd test -c "Test User,work,123,456" -N
 	atf_check -s exit:1 -o empty grep "^test:.*" $HOME/master.passwd
 }
 
 # Test add user with invalid comments
 atf_test_case user_add_comments_invalid
 user_add_comments_invalid_body() {
 	populate_etc_skel
 
 	atf_check -s exit:65 -e match:"invalid character" \
 		${PW} useradd test -c "Test User,work,123:456,456"
 	atf_check -s exit:1 -o empty \
 		grep "^test:.*:Test User,work,123:456,456:" $HOME/master.passwd
 }
 
 # Test add user with invalid comments and option -N
 atf_test_case user_add_comments_invalid_noupdate
 user_add_comments_invalid_noupdate_body() {
 	populate_etc_skel
 
 	atf_check -s exit:65 -e match:"invalid character" \
 		${PW} useradd test -c "Test User,work,123:456,456" -N
 	atf_check -s exit:1 -o empty grep "^test:.*" $HOME/master.passwd
 }
 
 # Test add user with alternate homedir
 atf_test_case user_add_homedir
 user_add_homedir_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd test -d /foo/bar
 	atf_check -s exit:0 -o match:"^test:\*:.*::0:0:User &:/foo/bar:.*" \
 		${PW} usershow test
 }
 
 # Test add user with account expiration as an epoch date
 atf_test_case user_add_account_expiration_epoch
 user_add_account_expiration_epoch_body() {
 	populate_etc_skel
 
 	DATE=`date -j -v+1d "+%s"`
 	atf_check -s exit:0 ${PW} useradd test -e ${DATE}
 	atf_check -s exit:0 -o match:"^test:\*:.*::0:${DATE}:.*" \
 		${PW} usershow test
 }
 
 # Test add user with account expiration as a DD-MM-YYYY date
 atf_test_case user_add_account_expiration_date_numeric
 user_add_account_expiration_date_numeric_body() {
 	populate_etc_skel
 
 	DATE=`date -j -v+1d "+%d-%m-%Y"`
 	EPOCH=`date -j -f "%d-%m-%Y %H:%M:%S" "${DATE} 00:00:00" "+%s"`
 	atf_check -s exit:0 ${PW} useradd test -e ${DATE}
 	atf_check -s exit:0 -o match:"^test:\*:.*::0:${EPOCH}:User &:.*" \
 		${PW} usershow test
 }
 
 # Test add user with account expiration as a DD-MM-YYYY date
 atf_test_case user_add_account_expiration_date_month
 user_add_account_expiration_date_month_body() {
 	populate_etc_skel
 
 	DATE=`date -j -v+1d "+%d-%b-%Y"`
 	EPOCH=`date -j -f "%d-%b-%Y %H:%M:%S" "${DATE} 00:00:00" "+%s"`
 	atf_check -s exit:0 ${PW} useradd test -e ${DATE}
 	atf_check -s exit:0 -o match:"^test:\*:.*::0:${EPOCH}:User &:.*" \
 		${PW} usershow test
 }
 
 # Test add user with account expiration as a relative date
 atf_test_case user_add_account_expiration_date_relative
 user_add_account_expiration_date_relative_body() {
 	populate_etc_skel
 
 	EPOCH=`date -j -v+13m "+%s"`
 	BUF=`expr $EPOCH + 5`
 	atf_check -s exit:0 ${PW} useradd test -e +13o
 	TIME=`${PW} usershow test | awk -F ':' '{print $7}'`
 	[ ! -z $TIME -a $TIME -ge $EPOCH -a $TIME -lt $BUF ] || \
 		atf_fail "Expiration time($TIME) was not within $EPOCH - $BUF seconds."
 }
 
 # Test add user with password expiration as an epoch date
 atf_test_case user_add_password_expiration_epoch
 user_add_password_expiration_epoch_body() {
 	populate_etc_skel
 
 	DATE=`date -j -v+1d "+%s"`
 	atf_check -s exit:0 ${PW} useradd test -p ${DATE}
 	atf_check -s exit:0 -o match:"^test:\*:.*::${DATE}:0:.*" \
 		${PW} usershow test
 }
 
 # Test add user with password expiration as a DD-MM-YYYY date
 atf_test_case user_add_password_expiration_date_numeric
 user_add_password_expiration_date_numeric_body() {
 	populate_etc_skel
 
 	DATE=`date -j -v+1d "+%d-%m-%Y"`
 	EPOCH=`date -j -f "%d-%m-%Y %H:%M:%S" "${DATE} 00:00:00" "+%s"`
 	atf_check -s exit:0 ${PW} useradd test -p ${DATE}
 	atf_check -s exit:0 -o match:"^test:\*:.*::${EPOCH}:0:User &:.*" \
 		${PW} usershow test
 }
 
 # Test add user with password expiration as a DD-MMM-YYYY date
 atf_test_case user_add_password_expiration_date_month
 user_add_password_expiration_date_month_body() {
 	populate_etc_skel
 
 	DATE=`date -j -v+1d "+%d-%b-%Y"`
 	EPOCH=`date -j -f "%d-%b-%Y %H:%M:%S" "${DATE} 00:00:00" "+%s"`
 	atf_check -s exit:0 ${PW} useradd test -p ${DATE}
 	atf_check -s exit:0 -o match:"^test:\*:.*::${EPOCH}:0:User &:.*" \
 		${PW} usershow test
 }
 
 # Test add user with password expiration as a relative date
 atf_test_case user_add_password_expiration_date_relative
 user_add_password_expiration_date_relative_body() {
 	populate_etc_skel
 
 	EPOCH=`date -j -v+13m "+%s"`
 	BUF=`expr $EPOCH + 5`
 	atf_check -s exit:0 ${PW} useradd test -p +13o
 	TIME=`${PW} usershow test | awk -F ':' '{print $6}'`
 	[ ! -z $TIME -a $TIME -ge $EPOCH -a $TIME -lt $BUF ] || \
 		atf_fail "Expiration time($TIME) was not within $EPOCH - $BUF seconds."
 }
 
 atf_test_case user_add_name_too_long
 user_add_name_too_long_body() {
 	populate_etc_skel
 	atf_check -e match:"too long" -s exit:64 \
 		${PW} useradd name_very_vert_very_very_very_long
 }
 
 atf_test_case user_add_name_with_spaces
 user_add_name_with_spaces_body() {
 	populate_etc_skel
 	atf_check -s exit:65 -e match:"invalid character" \
 		  ${PW} useradd 'test user'
 	atf_check -s exit:1 -o empty grep "^test user:.*" $HOME/master.passwd
 	# Try again with -n which uses a slightly different code path.
 	atf_check -s exit:65 -e match:"invalid character" \
 		  ${PW} useradd -n 'test user'
 	atf_check -s exit:1 -o empty grep "^test user:.*" $HOME/master.passwd
 }
 
 atf_test_case user_add_name_with_spaces_and_gid_specified
 user_add_name_with_spaces_and_gid_specified_body() {
 	populate_etc_skel
 	gid=12345
 	user_name="test user"
 	# pw useradd should fail because of the space in the user
 	# name, not because the group doesn't exist.
 	atf_check -s exit:65 -e match:"invalid character" \
 		  ${PW} useradd "${user_name}" -g ${gid}
 	atf_check -s exit:1 -o empty grep "^${user_name}:.*" $HOME/master.passwd
 	# Try again with -n which uses a slightly different code path.
 	atf_check -s exit:65 -e match:"invalid character" \
 		  ${PW} useradd -n "${user_name}" -g ${gid}
 	atf_check -s exit:1 -o empty grep "^${user_name}:.*" $HOME/master.passwd
 	# Make sure the user isn't added even if the group exists
 	atf_check -s exit:0 ${PW} groupadd blafasel -g ${gid}
 	atf_check -s exit:65 -e match:"invalid character" \
 		  ${PW} useradd "${user_name}" -g ${gid}
 	atf_check -s exit:1 -o empty grep "^${user_name}:.*" $HOME/master.passwd
 	# Try again with the -n option.
 	atf_check -s exit:65 -e match:"invalid character" \
 		  ${PW} useradd -n "${user_name}" -g ${gid}
 	atf_check -s exit:1 -o empty grep "^${user_name}:.*" $HOME/master.passwd
 }
 
 atf_test_case user_add_expiration
 user_add_expiration_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 \
 		${PW} useradd foo -e 20-03-2037
 	atf_check -o inline:"foo:*:1001:1001::0:2121120000:User &:/home/foo:/bin/sh\n" \
 		-s exit:0 grep "^foo" ${HOME}/master.passwd
 	atf_check -s exit:0 ${PW} userdel foo
 	atf_check -s exit:0 \
 		${PW} useradd foo -e 20-03-37
 	atf_check -o inline:"foo:*:1001:1001::0:2121120000:User &:/home/foo:/bin/sh\n" \
 		-s exit:0 grep "^foo" ${HOME}/master.passwd
 	atf_check -s exit:0 ${PW} userdel foo
 	atf_check -s exit:0 \
 		${PW} useradd foo -e 20-Mar-2037
 	atf_check -o inline:"foo:*:1001:1001::0:2121120000:User &:/home/foo:/bin/sh\n" \
 		-s exit:0 grep "^foo" ${HOME}/master.passwd
 	atf_check -s exit:0 ${PW} userdel foo
 	atf_check -e inline:"pw: Invalid date\n" -s exit:1 \
 		${PW} useradd foo -e 20-Foo-2037
 	atf_check -e inline:"pw: Invalid date\n" -s exit:1 \
 		${PW} useradd foo -e 20-13-2037
 	atf_check -s exit:0 ${PW} useradd foo -e "12:00 20-03-2037"
 	atf_check -s exit:0 ${PW} userdel foo
 	atf_check -e inline:"pw: Invalid date\n" -s exit:1 \
 		${PW} useradd foo -e "12 20-03-2037"
 	atf_check -s exit:0 ${PW} useradd foo -e "20-03-2037	12:00"
 	atf_check -s exit:0 ${PW} userdel foo
 }
 
 atf_test_case user_add_invalid_user_entry
 user_add_invalid_user_entry_body() {
 	touch ${HOME}/master.passwd
 	touch ${HOME}/group
 
 	pwd_mkdb -p -d ${HOME} ${HOME}/master.passwd || \
 		atf_fail "generate passwd from master.passwd"
 	atf_check -s exit:0 ${PW} useradd foo
 	echo "foo1:*:1002" >> ${HOME}/master.passwd
 	atf_check -s exit:1 -e match:"Invalid user entry" ${PW} useradd foo2
 }
 
 atf_test_case user_add_invalid_group_entry
 user_add_invalid_group_entry_body() {
 	touch ${HOME}/master.passwd
 	touch ${HOME}/group
 
 	pwd_mkdb -p -d ${HOME} ${HOME}/master.passwd || \
 		atf_fail "generate passwd from master.passwd"
 	atf_check -s exit:0 ${PW} useradd foo
 	echo 'foo1:*:1002' >> group
 	atf_check -s exit:1 -e match:"Invalid group entry" ${PW} useradd foo2
 }
 
 atf_test_case user_add_password_from_h
 user_add_password_from_h_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd foo -h 0 <<-EOF
 	$(echo mypassword)
 	EOF
 	passhash=`awk -F ':' '/^foo:/ {print $2}' $HOME/master.passwd`
 	atf_check -s exit:0 -o inline:$passhash \
 		$(atf_get_srcdir)/crypt $passhash "mypassword"
 }
 
 atf_test_case user_add_R
 user_add_R_body() {
 	populate_root_etc_skel
 
 	atf_check -s exit:0 ${RPW} useradd foo
 	atf_check -s exit:0 ${RPW} useradd bar -m
 	test -d ${HOME}/home || atf_fail "Home parent directory not created"
 	test -d ${HOME}/home/bar || atf_fail "Directory not created"
 	atf_check -s exit:0 ${RPW} userdel bar
 	test -d ${HOME}/home/bar || atf_fail "Directory removed"
 	atf_check -s exit:0 ${RPW} useradd bar
 	atf_check -s exit:0 ${RPW} userdel bar -r
 	[ ! -d ${HOME}/home/bar ] || atf_fail "Directory not removed"
 }
 
 atf_test_case user_add_R_symlink
 user_add_R_symlink_body() {
 	populate_root_etc_skel
 
 	mkdir ${HOME}/usr
 	atf_check -s exit:0 ${RPW} useradd foo -m
 	test -d ${HOME}/usr/home || atf_fail "Home parent directory not created"
 	test -h ${HOME}/home || atf_fail "/home directory is not a symlink"
 	atf_check -s exit:0 -o inline:"usr/home\n" readlink ${HOME}/home
 }
 
 atf_test_case user_add_skel
 user_add_skel_body() {
 	populate_root_etc_skel
 
 	mkdir ${HOME}/skel
 	echo "a" > ${HOME}/skel/.a
 	echo "b" > ${HOME}/skel/b
 	mkdir ${HOME}/skel/c
 	mkdir ${HOME}/skel/c/d
 	mkdir ${HOME}/skel/dot.plop
 	echo "c" > ${HOME}/skel/c/d/dot.c
 	mkdir ${HOME}/home
 	ln -sf /nonexistent ${HOME}/skel/c/foo
 	atf_check -s exit:0 ${RPW} useradd foo -k /skel -m
 	test -d ${HOME}/home/foo || atf_fail "Directory not created"
 	test -f ${HOME}/home/foo/.a || atf_fail "File not created"
 	atf_check -o file:${HOME}/skel/.a -s exit:0 cat ${HOME}/home/foo/.a
 	atf_check -o file:${HOME}/skel/b -s exit:0 cat ${HOME}/home/foo/b
 	test -d ${HOME}/home/foo/c || atf_fail "Dotted directory in skel not copied"
 	test -d ${HOME}/home/foo/.plop || atf_fail "Directory in skell not created"
 	atf_check -o inline:"/nonexistent\n" -s ignore readlink -f ${HOME}/home/foo/c/foo
 	atf_check -o file:${HOME}/skel/c/d/dot.c -s exit:0 cat ${HOME}/home/foo/c/d/.c
 }
 
 atf_test_case user_add_uid0
 user_add_uid0_body() {
 	populate_etc_skel
 	atf_check -e inline:"pw: WARNING: new account \`foo' has a uid of 0 (superuser access!)\n" \
 		-s exit:0 ${PW} useradd foo -u 0 -g 0 -d /root -s /bin/sh -c "Bourne-again Superuser" -o
 	atf_check \
 		-o inline:"foo:*:0:0::0:0:Bourne-again Superuser:/root:/bin/sh\n" \
 		-s exit:0 ${PW} usershow foo
 }
 
 atf_test_case user_add_uid_too_large
 user_add_uid_too_large_body() {
 	populate_etc_skel
 	atf_check -s exit:64 -e inline:"pw: Bad id '9999999999999': too large\n" \
 		${PW} useradd -n test1 -u 9999999999999
 }
 
 atf_test_case user_add_bad_shell
 user_add_bad_shell_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd foo -s sh
 	atf_check -s exit:78 -e ignore ${PW} useradd bar -s badshell
 }
 
 atf_test_case user_add_already_exists
 user_add_already_exists_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd foo
 	atf_check -s exit:65 \
 		-e inline:"pw: login name \`foo' already exists\n" \
 		${PW} useradd foo
 }
 
 atf_test_case user_add_w_error
 user_add_w_error_body() {
 	populate_etc_skel
 
 	atf_check -s exit:1 -e match:"pw: Invalid value for default password" \
 		${PW} useradd foo -w invalid_value
 }
 
 atf_test_case user_add_w_no
 user_add_w_no_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd foo -w no
 	atf_check -s exit:0 -o match:"^foo:\*" grep "^foo:" $HOME/master.passwd
 }
 
 atf_test_case user_add_w_none
 user_add_w_none_body() {
 	populate_etc_skel
 
 	atf_check -s exit:0 ${PW} useradd foo -w none
 	atf_check -s exit:0 -o match:"^foo::" grep "^foo:" $HOME/master.passwd
 }
 
 atf_test_case user_add_w_random
 user_add_w_random_body() {
 	populate_etc_skel
 
 	password=`${PW} useradd foo -w random | cat`
 	passhash=`awk -F ':' '/^foo:/ {print $2}' $HOME/master.passwd`
 	atf_check -s exit:0 -o inline:$passhash \
 		$(atf_get_srcdir)/crypt $passhash "$password"
 }
 
 atf_test_case user_add_w_yes
 user_add_w_yes_body() {
 	populate_etc_skel
 	password=`${PW} useradd foo -w random | cat`
 	passhash=`awk -F ':' '/^foo:/ {print $2}' $HOME/master.passwd`
 	atf_check -s exit:0 -o inline:$passhash \
 		$(atf_get_srcdir)/crypt $passhash "$password"
 }
 
 atf_test_case user_add_with_pw_conf
 user_add_with_pw_conf_body()
 {
 	populate_etc_skel
 	atf_check -s exit:0 \
 		${PW} useradd -D -C ${HOME}/pw.conf \
 		-u 2000,32767 -i 2000,32767
 	atf_check -s exit:0 \
 		-o inline:"minuid = 2000\nmaxuid = 32767\nmingid = 2000\nmaxgid = 32767\n" \
 		grep "^m.*id =" ${HOME}/pw.conf
 	atf_check -s exit:0 \
 		${PW} useradd foo -C ${HOME}/pw.conf
 }
+
 atf_test_case user_add_defaultgroup
 user_add_defaultgroup_body()
 {
 	populate_etc_skel
 	echo 'defaultgroup = "plop"' > ${HOME}/pw.conf
 	atf_check -s exit:0 \
 		${PW} groupadd plop -g 442
 	atf_check -s exit:0 \
 		${PW} useradd foo -C ${HOME}/pw.conf
 	atf_check -s exit:0 \
 		-o inline:"foo:*:1001:442::0:0:User &:/home/foo:/bin/sh\n" \
 		${PW} usershow foo
 }
 
+atf_test_case user_add_conf_defaultpasswd
+user_add_conf_defaultpasswd_body()
+{
+	populate_etc_skel
+
+	atf_check -s exit:0 ${PW} useradd -D -w no
+	atf_check -o inline:"defaultpasswd = \"no\"\n" \
+	    grep defaultpasswd ${HOME}/pw.conf
+	atf_check -s exit:0 ${PW} useradd -D -w none
+	atf_check -o inline:"defaultpasswd = \"none\"\n" \
+	    grep defaultpasswd ${HOME}/pw.conf
+	atf_check -s exit:0 ${PW} useradd -D -w random
+	atf_check -o inline:"defaultpasswd = \"random\"\n" \
+	    grep defaultpasswd ${HOME}/pw.conf
+	atf_check -s exit:0 ${PW} useradd -D -w yes
+	atf_check -o inline:"defaultpasswd = \"yes\"\n" \
+	    grep defaultpasswd ${HOME}/pw.conf
+}
+
 atf_init_test_cases() {
 	atf_add_test_case user_add
 	atf_add_test_case user_add_noupdate
 	atf_add_test_case user_add_comments
 	atf_add_test_case user_add_comments_noupdate
 	atf_add_test_case user_add_comments_invalid
 	atf_add_test_case user_add_comments_invalid_noupdate
 	atf_add_test_case user_add_homedir
 	atf_add_test_case user_add_account_expiration_epoch
 	atf_add_test_case user_add_account_expiration_date_numeric
 	atf_add_test_case user_add_account_expiration_date_month
 	atf_add_test_case user_add_account_expiration_date_relative
 	atf_add_test_case user_add_password_expiration_epoch
 	atf_add_test_case user_add_password_expiration_date_numeric
 	atf_add_test_case user_add_password_expiration_date_month
 	atf_add_test_case user_add_password_expiration_date_relative
 	atf_add_test_case user_add_name_too_long
 	atf_add_test_case user_add_name_with_spaces
 	atf_add_test_case user_add_name_with_spaces_and_gid_specified
 	atf_add_test_case user_add_expiration
 	atf_add_test_case user_add_invalid_user_entry
 	atf_add_test_case user_add_invalid_group_entry
 	atf_add_test_case user_add_password_from_h
 	atf_add_test_case user_add_R
 	atf_add_test_case user_add_R_symlink
 	atf_add_test_case user_add_skel
 	atf_add_test_case user_add_uid0
 	atf_add_test_case user_add_uid_too_large
 	atf_add_test_case user_add_bad_shell
 	atf_add_test_case user_add_already_exists
 	atf_add_test_case user_add_w_error
 	atf_add_test_case user_add_w_no
 	atf_add_test_case user_add_w_none
 	atf_add_test_case user_add_w_random
 	atf_add_test_case user_add_w_yes
 	atf_add_test_case user_add_with_pw_conf
 	atf_add_test_case user_add_defaultgroup
+
+	atf_add_test_case user_add_conf_defaultpasswd
 }