newuidmap,newgidmap: Correct the range size sanity check in get_map_ranges

The number of ranges should be the ceiling of the number of arguments divided by three. Without this fix newuidmap and newgidmap always report and error and fail, which is very much not what we want. Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com> Signed-off-by: Serge Hallyn <serge.hallyn@ubuntu.com>
Improve vipw error report when editor fails
2013-09-10 17:51:40 -05:00 · 2013-08-25 16:27:58 +02:00 · 2013-08-23 16:00:36 -05:00 · 2013-08-23 22:31:00 +02:00 · 2013-08-23 15:16:43 -05:00 · 2013-08-23 20:29:43 +02:00
489 changed files with 175890 additions and 65637 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,47 @@
+*~
+lib*.a
+*.o
+*.lo
+*.la
+*.gmo
+.deps
+.libs
+
+*.patch
+*.rej
+*.orig
+
+Makefile
+Makefile.in
+
+/ABOUT-NLS
+/aclocal.m4
+/autom4te.cache
+/config.guess
+/config.h
+/config.h.in
+/config.log
+/config.rpath
+/config.status
+/config.sub
+/configure
+/depcomp
+/install-sh
+/libtool
+/ltmain.sh
+/m4
+/missing
+/stamp-h1
+/ylwrap
+
+/po/*.header
+/po/*.sed
+/po/*.sin
+/po/Makefile.in.in
+/po/Makevars.template
+/po/POTFILES
+/po/Rules-quot
+/po/stamp-po
+
+/shadow.spec
+/libmisc/getdate.c
--- a/6666
+++ b/6666
--- a/447
+++ b/447
@@ -1,5 +1,450 @@
 $Id$

+shadow-4.1.5.1 -> shadow-4.2					UNRELEASED
+
+*** general
+  * Handle libc whose crypt() returns NULL when passed a salt that
+    violates specs or system requirements (e.g. FIPS140). This is needed
+    with glibc/eglibc 2.17 for tools checking passwords (passwd (non PAM
+    enabled) or newgrp), and for tools generating encrypted passwords
+    (chgpasswd, chpasswd, or gpasswd when non PAM enabled or when a fixed
+    crypt method is requested on the command line, and newusers, or passwd
+    in their non PAM enabled versions)
+  * Fix segfault when reading groups split on multiple lines. This impacts
+    most user/group management tools when MAX_MEMBERS_PER_GROUP is set.
+
+- su
+  * When su receives a signal (SIGTERM, or SIGINT/SIGQUIT in non
+    interactive mode), kill the child process group, rather than just the 
+    immediate child.
+  * Fix segmentation faults for users without a proper home or shell in
+    their passwd entries.
+
+- login
+  * Fix segmentation faults for users without a proper home or shell in
+    their passwd entries.
+
+*** documentation
+  * Fixed useradd man page (--home-dir option, instead of --home).
+
+*** translation
+  * Updated Russian translation.
+  * Updated German man pages translation.
+  * Fixed gshadow Japanese man page translation.
+
+shadow-4.1.5 -> shadow-4.1.5.1					2012-05-25
+
+- login
+  * Log into utmp(x) when PAM is enabled, but do not log into wtmp.
+    This complete pam_lastlog which logs into wtmp and in into utmp(x).
+- su
+  * non PAM enabled versions: do not fail if su is called without a
+    controlling terminal.
+- userdel
+  * Fix segfault when userdel removes the user's group.
+
+*** documentation
+  * .so links now point to paths relative to the top-level manual hierarchy
+
+*** translation
+  * Updated French man pages translation.
+  * Updated German man pages translation.
+  * Updated Polish man pages translation. (logoutd.8)
+
+shadow-4.1.4.3 -> shadow-4.1.5					2012-02-12
+
+*** security
+  * su -c could be abused by the executed command to invoke commands with
+    the caller privileges. See below. (CVE-2005-4890)
+
+*** general
+  * report usage error to stderr, but report usage help to stdout (and return
+    zero) when explicitly requested (e.g. with --help).
+  * initial support for tcb (http://openwall.com/tcb/) for useradd,
+    userdel, usermod, chage, pwck, vipw.
+  * Added support for ACLs and Extended Attributes in useradd and usermod.
+    Support shall be enabled with the new --with-acl or --with-attr
+    configure options.
+  * Added diagnosis for lock failures.
+  * use libsemanage instead of the semanage tool.
+
+- chage
+  * Add --root option.
+- chfn
+  * Add --root option.
+- chgpasswd
+  * When the gshadow file exists but there are no gshadow entries, an entry
+    is created if the password is changed and group requires a
+    shadow entry.
+  * Add --root option.
+- chpasswd
+  * PAM enabled versions: restore the -e option to allow restoring
+    passwords without knowing those passwords. Restore together the -m
+    and -c options. (These options were removed in shadow-4.1.4 on PAM
+    enabled versions)
+  * When the shadow file exists but there are no shadow entries, an entry
+    is created if the password is changed and passwd requires a
+    shadow entry.
+  * Add --root option.
+- chsh
+  * Add --root option.
+- faillog
+  * The -l, -m, -r, -t options only act on the existing users, unless -a is
+    specified.
+  * Add --root option.
+- gpasswd
+  * Add --root option.
+- groupadd
+  * Add --root option.
+- groupdel
+  * Add --root option.
+- groupmems
+  * Fix parsing of gshadow entries.
+  * Add --root option.
+- groupmod
+  * Fixed groupmod when configured with --enable-account-tools-setuid.
+  * When the gshadow file exists but there are no gshadow entries, an entry
+    is created if the password is changed and group requires a
+    shadow entry.
+  * Add --root option.
+- grpck
+  * Add --root option.
+  * NIS entries were dropped by -s (sort).
+- grpconv
+  * Add --root option.
+- grpunconv
+  * Add --root option.
+- lastlog
+  * Add --root option.
+- login
+  * Fixed limits support (non PAM enabled versions only)
+  * Added support for infinite limits and group based limits (non PAM
+    enabled versions only)
+  * Fixed infinite loop when CONSOLE is configured with a colon-separated
+    list of TTYs.
+  * Fixed warning and support for CONSOLE_GROUPS for users member of more
+    than 16 groups.
+  * Do not log into utmp(x) or wtmp when PAM is enabled. This is done by
+    pam_lastlog.
+- newgrp, sg
+  * Fix parsing of gshadow entries.
+- newusers
+  * Add --root option.
+- passwd
+  * Add --root option.
+- pwpck
+  * NIS entries were dropped by -s (sort).
+  * Add --root option.
+- pwconv
+  * Add --root option.
+- pwunconv
+  * Add --root option.
+- useradd
+  * If the skeleton directory contained hardlinked files, copies of the
+    hardlink were removed from the skeleton directory.
+  * Add --root option.
+- userdel
+  * Check the existence of the user's mail spool before trying to remove
+    it. If it does not exist, a warning is issued, but no failure.
+  * Do not remove a group with the same name as the user (usergroup) if
+    this group isn't the user's primary group.
+  * Add --root option.
+  * Add --selinux-user option.
+- usermod
+  * Accept options in any order (username not necessarily at the end)
+  * When the shadow file exists but there are no shadow entries, an entry
+    is created if the password is changed and passwd requires a
+    shadow entry, or if aging features are used (-e or -f).
+  * Add --root option.
+- su
+  * Document the su exit values.
+  * When su receives a signal, wait for the child to terminate (after
+    sending a SIGTERM), and kill it only if it did not terminate by itself.
+    No delay will be enforced if the child cooperates.
+  * Default ENV_SUPATH is /sbin:/bin:/usr/sbin:/usr/bin
+  * Fixed infinite loop when CONSOLE is configured with a colon-separated
+    list of TTYs.
+  * Fixed warning and support for CONSOLE_GROUPS for users member of more
+    than 16 groups.
+  * Do not forward the controlling terminal to commands executed with -c.
+    This prevents tty hijacking which could lead to execution with the
+    caller's privileges.
+  * Close PAM sessions as root. This will be more friendly to PAM modules
+    like pam_mount or pam_systemd.
+  * Added support for PAM modules which change PAM_USER.
+
+*** translation
+  * Updated Brazilian Portuguese translation.
+  * Updated Catalan translation.
+  * Updated Czech translation.
+  * Updated Danish translation.
+  * New Danish man pages translation.
+  * Updated French translation.
+  * Updated French man pages translation.
+  * Updated German translation.
+  * Updated German man pages translation.
+  * Updated Greek translation.
+  * Updated Italian man pages translation.
+  * Updated Japanese translation.
+  * Updated Kazakh translation.
+  * Updated Norwegian Bokmål translation.
+  * Updated Portuguese translation.
+  * Updated Russian translation.
+  * Updated Simplified Chinese translation.
+  * Updated Simplified Chinese man pages translation.
+  * Updated Swedish translation.
+  * Updated Vietnamese translation.
+
+shadow-4.1.4.2 -> shadow-4.1.4.3						2011-02-15
+
+*** security
+- CVE-2011-0721: An insufficient input sanitation in chfn can be exploited
+  to create users or groups in a NIS environment.
+
+shadow-4.1.4.1 -> shadow-4.1.4.2					2009-07-24
+
+- general
+  * Improved support for large groups (impacts most user/group management
+    tools).
+
+- addition of system users or groups
+  * Speed improvement. This should be noticeable in case of LDAP configured
+    systems. This should impact useradd, groupadd, and newusers
+  * Since system accounts are allocated from SYS_?ID_MIN to SYS_?ID_MAX in
+    reverse order, accounts are packed close to SYS_?ID_MAX if SYS_?ID_MIN
+    is already used but there are still dome gaps.
+
+- login
+  * Add support for shells being a shell script without a shebang.
+- su
+  * Preserve the DISPLAY and XAUTHORITY environment variables. This was
+    only the case in the non PAM enabled versions.
+  * Add support for shells being a shell script without a shebang.
+
+*** translation
+  * The Finnish translation of passwd(1) was outdated and is no more
+    distributed.
+
+shadow-4.1.4 -> shadow-4.1.4.1						2009-05-22
+
+- login
+  * Fix failures with empty usernames on non PAM versions.
+  * Fix CONSOLE (securetty) support on non PAM versions.
+- newgrp
+  * Return the exit status of the child.
+- userdel
+  * On Linux, do not check if an user is logged in with utmp, but check if
+    the user is running some processes.
+  * If not on Linux, continue to search for an utmp record, but make sure
+    the process recorded in the utmp entry is still running.
+  * Report failures to remove the user's mailbox
+  * When USERGROUPS_ENAB is enabled, remove the user's group when the
+    user was the only member.
+  * Do not fail when -r is used and the home directory does not exist.
+- usermod
+  * Check if the user is busy when the user's UID, name or home directory
+    is changed.
+
+shadow-4.1.3.1 -> shadow-4.1.4						2009-05-10
+
+- packaging
+  * Enable --enable-account-tools-setuid by default for PAM builds.
+  * Add configure option --enable-utmpx, disabled by default to mimic
+    the previous behavior on Linux (where utmp and utmpx are identical).
+  * Fix build failure on non-PAM systems when --without-pam is not
+    specified.
+
+- chpasswd
+  * Change the passwords using PAM. This permits to define the password
+    policy in a central place. The -c/--crypt-method, -e/--encrypted,
+    -m/--md5 and -s/--sha-rounds options are no more supported on PAM
+    enabled systems.
+- grpck
+  * Warn if a group has an entry in group and gshadow, and the password
+    field in group is not 'x'.
+- login
+  * Do not trust the current utmp entry's ut_line to set PAM_TTY. This could
+    lead to DOS attacks.
+  * (PAM) Even if the user was already authenticated (-f flag), ask the
+    user to update his authentication token if needed.
+- lastlog
+  * Fix regression causing empty reports.
+- newusers
+  * Change the passwords using PAM. This permits to define the password
+    policy in a central place. The -c/--crypt-method and -s/--sha-rounds
+    options are no more supported on PAM enabled systems.
+- pwck
+  * Warn if an user has an entry in passwd and shadow, and the password
+    field in passwd is not 'x'.
+
+*** translation
+ - Updated Czech translation
+ - Updated French translation
+ - Updated German translation
+ - Updated Japanese translation
+ - Updated Korean translation
+ - Updated Portuguese translation
+ - Updated Russian translation
+
+shadow-4.1.3 -> shadow-4.1.3.1						2009-04-15
+
+*** security:
+- Due to bad parsing of octal permissions, the permissions on tty (login)
+  but also UMASK were set wrongly (and weirdly). Only shadow-4.1.3 was
+  affected.
+
+*** general
+- login
+  * Fix regression when no user is specified on the command line.
+- userdel
+  * Fixed SE Linux support
+- vipw
+  * SE Linux: Set the default context to the context of the file being
+    edited. This ensures that the backup file inherit from the file's
+    context.
+
+*** translation
+ - Updated Norwegian Bokmål translation
+
+shadow-4.1.2.2 -> shadow-4.1.3						2009-04-12
+
+*** general:
+- packaging
+  * Fixed support for OpenPAM.
+  * Fixed support for uclibc.
+  * Added configure --enable-account-tools-setuid (default) /
+    --disable-account-tools-setuid options. This permits to disable the
+    PAM authentication of the caller for chage, chgpasswd, chpasswd,
+    groupadd, groupdel, groupmod, newusers, useradd, userdel, and usermod.
+    This authentication is not necessary when these tools are not
+    installed setuid root.
+  * Added configure --with-group-name-max-length (default) /
+    --without-group-name-max-length options. This permits to configure the maximum length allowed for group names:
+      <no option> -> default of 16 (like today)
+      --with-group-name-max-length -> default of 16
+      --without-group-name-max-length -> no max length
+      --with-group-name-max-length=n > max is set to n
+    No sanity checking is performed on n so people could do
+    something neat like --with-group-name-max-length=MAX_INT
+- addition of users or groups
+  * Speed improvement in case UID_MAX/SYS_UID_MAX/GID_MAX/SYS_GID_MAX is
+    used for an user/group. This should be noticeable in case of LDAP
+    configured systems. This should impact useradd, groupadd, and newusers
+- error handling improvement
+  * Make sure errors and incomplete changes are reported to syslog and
+    audit in case of unexpected failures.
+  * Report system inconsistencies to syslog and audit.
+  * Only report success to syslog and audit if the changes are really
+    performed in the system databases.
+    This is still not complete.
+- /etc/login.defs
+  * New CREATE_HOME variable to tell useradd to create a home directory by
+    default.
+- Translations
+  * New Kazakh translation.
+  * Spanish manpages are no more distributed. They are outdated. Please
+    contact pkg-shadow-devel@lists.alioth.debian.org if you wish to
+    provide updates.
+
+- faillog
+  * Accept users specified as a numerical UID, or ranges of users (-user,
+    user-, user1-user2).
+  * -l, -m, and -r now apply not only to existing users, but to all the
+    specified UIDs.
+  * Options can be specified in any order.
+- gpasswd
+  * Added support for long options --add (-a), --delete (-d),
+    --remove-password (-r), --restrict (-R), --administrators (-A), and
+    --members (-M).
+  * Added support for usernames with arbitrary length.
+  * audit logging improvements.
+  * error handling improvement (see above).
+  * Log permission denied to syslog and audit.
+- groupadd
+  * audit logging improvements.
+  * error handling improvement (see above).
+  * Speedup (see "addition of users or groups" above).
+  * do not create groups with GID set to (gid_t)-1.
+  * Allocate system group GIDs in reverse order. This could be useful
+    later to increase the static IDs range.
+- groupdel
+  * audit logging improvements.
+  * error handling improvement (see above).
+- groupmems
+  * Check if user exist before they are added to groups.
+  * Avoid segfault in case the specified group does not exist in /etc/group.
+  * Everybody is allowed to list the users of a group.
+  * /etc/group is open readonly when one just wants to list the users of a
+    group.
+  * Added syslog support.
+  * Use the groupmems PAM service name instead of groupmod.
+  * Fix segmentation faults when adding or removing users from a group.
+  * Added support for shadow groups.
+  * Added support long options --add (-a), --delete (-d), --purge (-p),
+    --list (-l), --group (-g).
+- groupmod
+  * audit logging improvements.
+  * error handling improvement (see above).
+  * do not create groups with GID set to (gid_t)-1.
+- grpck
+  * warn for groups with GID set to (gid_t)-1.
+- login
+  * Restore the echoctl, echoke, onclr flags to the terminal termio flags.
+    Reset echoprt, noflsh, tostop. This behavior seems to have change by
+    mistake in earlier releases (4.0.8, for no obvious reason).
+- newusers
+  * Implement the -r, --system option.
+  * Speedup (see "addition of users or groups" above).
+  * do not create users with UID set to (gid_t)-1.
+  * do not create groups with GID set to (gid_t)-1.
+  * Allocate system account UIDs/GIDs in reverse order. This could be useful
+    later to increase the static IDs range.
+- passwd
+  * For compatibility with other passwd version, the --lock an --unlock
+    options do not lock or unlock the user account anymore.  They only
+    lock or unlock the user's password.
+- pwck
+  * warn for users with UID set to (uid_t)-1.
+- su
+  * Preserve COLORTERM in addition to TERM when su is called with the -l
+    option.
+- useradd
+  * audit logging improvements.
+  * Speedup (see "addition of users or groups" above).
+  * See CREATE_HOME above.
+  * New -M/--no-create-home option to disable CREATE_HOME.
+  * do not create users with UID set to (gid_t)-1.
+  * Added -Z option to map SELinux user for user's login.
+  * Allocate system user UIDs in reverse order. This could be useful
+    later to increase the static IDs range.
+- userdel
+  * audit logging improvements.
+  * Do not fail if the removed user is not in the shadow database.
+  * When the user's group shall be removed, do not fail if this group is
+    not in the gshadow file.
+  * Delete the SELinux user mapping for user's login.
+- usermod
+  * Allow adding LDAP users (or any user not present in the local passwd
+    file) to local groups
+  * do not create users with UID set to (gid_t)-1.
+  * Added -Z option to map SELinux user for user's login.
+
+shadow-4.1.2.1 -> shadow-4.1.2.2					23-11-2008
+
+*** security
+- Fix a race condition in login that could lead to gaining ownership or
+  changing mode of arbitrary files.
+- Fix a possible login DOS, which could be caused by injecting forged
+  entries in utmp.
+
+shadow-4.1.2 -> shadow-4.1.2.1						26-06-2008
+
+*** security
+- Fix an "audit log injection" vulnerability in login.
+  This vulnerability makes it easier for attackers to hide activities by
+  modifying portions of log events, e.g. by appending an addr= statement
+  to the login name.
+
 shadow-4.1.1 -> shadow-4.1.2						25-05-2008

 *** security:
@@ -66,7 +511,7 @@ shadow-4.1.0 -> shadow-4.1.1						02-04-2008
    faillog faster.
 - gpasswd
  * Fix failures when the gshadow file is not present.
-  * When a password is moved to the gshadow file, use "x" instead of "x"
+  * When a password is moved to the gshadow file, use "x" instead of "!"
    to indicate that the password is shadowed (consistency with grpconv).
  * Make sure the group and gshadow files are unlocked on exit.
 - groupadd
--- a/23
+++ b/23
@@ -1,14 +1,19 @@
 Shadow SITES
 ============

+Homepage
+	http://pkg-shadow.alioth.debian.org/
+
 FTP site
 	ftp://pkg-shadow.alioth.debian.org/pub/pkg-shadow

 SVN repository
-	anonymous read only access: svn://svn.debian.org/pkg-shadow/
+	anonymous read only access: svn://svn.debian.org/pkg-shadow/upstream

 SVN web interface
-	http://svn.debian.org/wsvn/pkg-shadow
+	http://svn.debian.org/wsvn/pkg-shadow/upstream
+	or
+	http://svn.debian.org/viewsvn/pkg-shadow/upstream

 Mailing lists
 	for general discuss: pkg-shadow-devel@lists.alioth.debian.org
@@ -32,7 +37,7 @@ S/Key support:
 Authors and contributors
 ========================

-Thanks to at least the following people for sending me patches, bug
+Thanks to at least the following people for sending patches, bug
 reports and various comments.  This list may be incomplete, I received
 a lot of mail...

@@ -51,6 +56,7 @@ Calle Karlsson <ckn@kash.se>
 Chip Rosenthal <chip@unicom.com>
 Chris Evans <lady0110@sable.ox.ac.uk>
 Cristian Gafton <gafton@sorosis.ro>
+Dan Walsh <dwalsh@redhat.com>
 Darcy Boese <possum@chardonnay.niagara.com>
 Dave Hagewood <admin@arrowweb.com>
 David A. Holland <dholland@hcs.harvard.edu>
@@ -63,6 +69,7 @@ Greg Mortensen <loki@world.std.com>
 Guido van Rooij
 Guy Maor <maor@debian.org>
 Hrvoje Dogan <hdogan@bjesomar.srce.hr>
+Jakub Hrozek <jhrozek@redhat.com>
 Janos Farkas <chexum@bankinf.banki.hu>
 Jay Soffian <jay@lw.net>
 Jesse Thilo <Jesse.Thilo@pobox.com>
@@ -74,23 +81,30 @@ Joshua Cowan <jcowan@hermit.reslife.okstate.edu>
 Judd Bourgeois <shagboy@bluesky.net>
 Juergen Heinzl <unicorn@noris.net>
 Juha Virtanen <jiivee@iki.fi>
+Julian Pidancet <julian.pidancet@gmail.com>
 Julianne Frances Haugh <jockgrrl@ix.netcom.com>
 Leonard N. Zubkoff <lnz@dandelion.com>
 Luca Berra <bluca@www.polimi.it>
+Lukáš Kuklínek <lkukline@redhat.com>
 Lutz Schwalowsky <schwalow@mineralogie.uni-hamburg.de>
 Marc Ewing <marc@redhat.com>
 Martin Bene <mb@sime.com>
 Martin Mares <mj@gts.cz>
 Michael Meskes <meskes@topsystem.de>
 Michael Talbot-Wilson <mike@calypso.bns.com.au>
+Mike Frysinger <vapier@gentoo.org>
 Mike Pakovic <mpakovic@users.southeast.net>
 Nicolas François <nicolas.francois@centraliens.net>
 Nikos Mavroyanopoulos <nmav@i-net.paiko.gr>
 Pavel Machek <pavel@bug.ucw.cz>
+Peter Vrabec <pvrabec@redhat.com>
 Phillip Street
 Rafał Maszkowski <rzm@icm.edu.pl>
 Rani Chouha <ranibey@smartec.com>
 Sami Kerola <kerolasa@rocketmail.com>
+Scott Garman <scott.a.garman@intel.com>
+Sebastian Rick Rijkers <srrijkers@gmail.com>
+Seraphim Mellos <mellos@ceid.upatras.gr>
 Shane Watts <shane@nexus.mlckew.edu.au>
 Steve M. Robbins <steve@nyongwa.montreal.qc.ca>
 Thorsten Kukuk <kukuk@suse.de>
@@ -102,5 +116,6 @@ Werner Fink <werner@suse.de>
 Maintainers
 ===========

-Tomasz Kłoczko <kloczek@pld.org.pl> (2000-2006)
+Tomasz Kłoczko <kloczek@pld.org.pl> (2000-2007)
+Nicolas François <nicolas.francois@centraliens.net> (2007-now)

--- a/121
+++ b/121
@@ -1,11 +1,45 @@
-passwd -l should lock the password, not the account.
+ * Create a common usage function that'd take the array of     
+   long options and an array of descriptions and output that so things would
+   be standardized across the utils.
+   Usage strings should be normalized and split first.
+   Investigate optparse.

-vipw: Test SHADOWGRP support before using gshadow features.

-PAM: add support for customization of the PAM support (i.e. support the
-Debian PAM configuration)
+/etc/default/useradd
+ * GROUP=1000 should accept a group name.

-PAM: check if a non-interactive conversation function could be used to 
+Check when RLOGIN is enabled if ruserok() exists
+
+Move selinux_file_context out of libmisc/copydir.c
+
+Review hardcoded root account?
+
+review all call to strto
+
+libmisc/cleanup_user.c
+	cleanup needed (cleanup_report_add_user* not used)
+
+
+libxcrypt support
+ * http://wiki.linuxfromscratch.org/patches/browser/trunk/shadow/shadow-4.0.18.1-owl_blowfish-1.patch
+
+implement getlong, getulong.
+	avoid atoi, atol, atoul, strtol, strtoul, ...
+
+manpages: comment the RLOGIN parts
+
+Replace build_list (in lib/gshadow.c) and list (in lib/sgetgrent.c) by
+comma_to_list()
+
+Revert the modified files if all files could not be changed.
+  * or warn and indicate which files were modified and which were not.
+  * check the order the files are modified.
+
+report nscd_flush_cache failures?
+call nscd from the programs or from lib (commonio?)
+
+PAM: check if a non-interactive conversation function could be used to set
+the password in chpasswd and newusers

 WITH_SELINUX
  - review all tools to check that the strategies are consistent
@@ -13,33 +47,20 @@ WITH_SELINUX
 chage, chfn, chsh: same change needed as in passwd.
  - probably need moving check_selinux_access to a separate file.

-man useradd
-	document default behavior for GROUP
-	remove "The default group number is 1 or whatever is..."
-
-useradd manpage
-  - add -k option
-  - mention that -o require -u
-
 testsuite
 - newgrp
   - test with unknown user's GID

 newusers
 - add logging to SYSLOG & AUDIT
-
-faillog
- - accept numerical user and range of users
+ - use CREATE_HOME
+ - Add a -Z option (see useradd / usermod)

 Document when/where option appeared, document whether an option is standard
 or not.

-depends rules for the manpages
-
 Check all the expiry semantics

-Add options --crypt-method and --sha-rounds to gpasswd
-
 ALL:
 - move base passwd/shadow/group/gshadow operation to module for allow write
  different backend modules for db, NIS, LDAP and others. Default backend it
@@ -49,38 +70,58 @@ ALL:
  passwd have old piece of code with handling -r option and it will be good
  finish this and propagate on other shadow tools for allow operate on other
  user databases by well known tools.
+- Protect against signals. Register do_cleanups in a signal handler.
+
+- login.defs
+  - generate depending on configuration

 - useradd:
  - add handle create user mail spool in maildir format.
-
- add handle -n switch in groups and id command for allow query is
-  group/user with specified id/gid exist - this will be very usable
-  on automation in packages for query/check is group/user exist in system
-  or not,
-
- groupmems: 
-  - need some work on add PAM and i18n support.
+  - Add support for -k in -D mode
+  - Add support for -K in -D mode
+  - Add option to create or not the mail spool (and set the default in -D
+    mode)
+  - Change -l to reset the entry if an entry was already there
+  - set the mask in mkdir?

 - userdel:
  - add backup option for the removal of user resources,
-  - add lookop and remove per user group.
  - user_busy: check that the user is not running any processes.
+  - missing "deleting group" FAILED
+  - home dir removed, but userdel may fail and may leave the user
+    => warning needed
+
+- usermod
+  - add an option equivalent to useradd's -l (only when uid is changed)
+  - the mode of new home directories should be set according to the
+    original mode. Does copy_tree does this?
+  - user renamed, order is not kept in /etc/group (see
+    47_usermod-l_no_shadow_file). This is a problem when the first user is
+    considered as the admin.
+  - see mail "user ID change" on  April, 15
+    + fix call to chown (combination of -m and -u/-g)
+    + add tests

 - passwd:
  - check combination of options (e.g. -u/-l)
+  - when -u refuse to unlock because it would create an empty password, it
+    should not display "Password changed."
+    exit instead?

 - newgrp: check the USE_PAM section.

- groupmems: check reason for isgroup
+- pwck
+  - Add check to move passwd passwords to shadow if there is a shadow
+    entry (with a password).
+  - Add check to move passwd passwords to shadow if there is a shadow
+    file.
+  - Support an alternative /etc/tcb directory as second parameter.
+  - add options -g / -G to specify alternative group / gshadow files

- newusers: doc for pw_gid not clear. Differentiate
-            pw_gid specified and exist
-            pw_gid specified but does not exist
-             * name
-             * number
-            pw_gid not specified.
- newusers: document what happens when no uid is specified.
- newusers: add option --system?
+- su
+  - add a login.defs configuration parameter to add variables to keep in
+    the environment with "su -l" (TERM/TERMCOLOR/...)

-Documentation:
- * document when options were added.
+- vipw
+  - set ACLs and XATTRs on the temporary file (and backups?)
+  - vipw + selinux -> use lib/selinux.c
--- a/autogen.sh
+++ b/autogen.sh
@@ -1,5 +1,7 @@
 #! /bin/sh
+
 autoreconf -v -f --install || exit 1
+
 ./configure \
 	CFLAGS="-O2 -Wall" \
 	--enable-man \
--- a/configure.in
+++ b/configure.in
@@ -1,6 +1,6 @@
 dnl Process this file with autoconf to produce a configure script.
 AC_INIT
-AM_INIT_AUTOMAKE(shadow, 4.1.2)
+AM_INIT_AUTOMAKE(shadow, 4.2)
 AC_CONFIG_HEADERS([config.h])

 dnl Some hacks...
@@ -19,7 +19,6 @@ AC_PROG_CC
 AC_ISC_POSIX
 AC_PROG_LN_S
 AC_PROG_YACC
-AM_C_PROTOTYPES
 AM_PROG_LIBTOOL

 dnl Checks for libraries.
@@ -28,19 +27,22 @@ dnl Checks for header files.
 AC_HEADER_DIRENT
 AC_HEADER_STDC
 AC_HEADER_SYS_WAIT
+AC_HEADER_STDBOOL

 AC_CHECK_HEADERS(errno.h fcntl.h limits.h unistd.h sys/time.h utmp.h \
 	utmpx.h termios.h termio.h sgtty.h sys/ioctl.h syslog.h paths.h \
 	utime.h ulimit.h sys/resource.h gshadow.h lastlog.h \
-	locale.h rpc/key_prot.h netdb.h)
+	locale.h rpc/key_prot.h netdb.h acl/libacl.h attr/libattr.h \
+	attr/error_context.h)

 dnl shadow now uses the libc's shadow implementation
 AC_CHECK_HEADER([shadow.h],,[AC_MSG_ERROR([You need a libc with shadow.h])])

-AC_CHECK_FUNCS(l64a fchmod fchown fsync getgroups gethostname getspnam \
+AC_CHECK_FUNCS(l64a fchmod fchown fsync futimes getgroups gethostname getspnam \
 	gettimeofday getusershell getutent initgroups lchown lckpwdf lstat \
-	memcpy memset setgroups sigaction strchr updwtmp updwtmpx innetgr \
-	getpwnam_r getpwuid_r getgrnam_r getgrgid_r getspnam_r)
+	lutimes memcpy memset setgroups sigaction strchr updwtmp updwtmpx innetgr \
+	getpwnam_r getpwuid_r getgrnam_r getgrgid_r getspnam_r getaddrinfo \
+	ruserok)
 AC_SYS_LARGEFILE

 dnl Checks for typedefs, structures, and compiler characteristics.
@@ -51,41 +53,39 @@ AC_TYPE_PID_T
 AC_TYPE_MODE_T
 AC_HEADER_STAT
 AC_CHECK_MEMBERS([struct stat.st_rdev])
+AC_CHECK_MEMBERS([struct stat.st_atim])
+AC_CHECK_MEMBERS([struct stat.st_atimensec])
+AC_CHECK_MEMBERS([struct stat.st_mtim])
+AC_CHECK_MEMBERS([struct stat.st_mtimensec])
 AC_HEADER_TIME
 AC_STRUCT_TM

-if test "$ac_cv_header_utmp_h" = "yes"; then
-	AC_CACHE_CHECK(for ut_host in struct utmp,
-		ac_cv_struct_utmp_ut_host,
-		AC_COMPILE_IFELSE(
-			[AC_LANG_PROGRAM([#include <utmp.h>],
-				[struct utmp ut; char *cp = ut.ut_host;]
-			)],
-			[ac_cv_struct_utmp_ut_host=yes],
-			[ac_cv_struct_utmp_ut_host=no]
-		)
-	)
-
-	if test "$ac_cv_struct_utmp_ut_host" = "yes"; then
-		AC_DEFINE(UT_HOST, 1, [Define if you have ut_host in struct utmp.])
-	fi
-
-	AC_CACHE_CHECK(for ut_user in struct utmp,
-		ac_cv_struct_utmp_ut_user,
-		AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <utmp.h>],
-				[struct utmp ut; char *cp = ut.ut_user;]
-			)],
-			[ac_cv_struct_utmp_ut_user=yes],
-			[ac_cv_struct_utmp_ut_user=no]
-		)
-	)
-
-	if test "$ac_cv_struct_utmp_ut_user" = "no"; then
-		AC_DEFINE(ut_user, ut_name,
-			[Define to ut_name if struct utmp has ut_name (not ut_user).])
-	fi
+AC_CHECK_MEMBERS([struct utmp.ut_type,
+                  struct utmp.ut_id,
+                  struct utmp.ut_name,
+                  struct utmp.ut_user,
+                  struct utmp.ut_host,
+                  struct utmp.ut_syslen,
+                  struct utmp.ut_addr,
+                  struct utmp.ut_addr_v6,
+                  struct utmp.ut_time,
+                  struct utmp.ut_xtime,
+                  struct utmp.ut_tv],,,[[#include <utmp.h>]])
+dnl There are dependencies:
+dnl If UTMPX has to be used, the utmp structure shall have a ut_id field.
+if test "$ac_cv_header_utmpx_h" = "yes" &&
+   test "$ac_cv_member_struct_utmp_ut_id" != "yes"; then
+	AC_MSG_ERROR(Systems with UTMPX and no ut_id field in the utmp structure are not supported)
 fi

+AC_CHECK_MEMBERS([struct utmpx.ut_name,
+                  struct utmpx.ut_host,
+                  struct utmpx.ut_syslen,
+                  struct utmpx.ut_addr,
+                  struct utmpx.ut_addr_v6,
+                  struct utmpx.ut_time,
+                  struct utmpx.ut_xtime],,,[[#include <utmpx.h>]])
+
 if test "$ac_cv_header_lastlog_h" = "yes"; then
 	AC_CACHE_CHECK(for ll_host in struct lastlog,
 		ac_cv_struct_lastlog_ll_host,
@@ -113,7 +113,6 @@ AC_REPLACE_FUNCS(sgetgrent sgetpwent sgetspent)
 AC_REPLACE_FUNCS(snprintf strcasecmp strdup strerror strstr)

 AC_CHECK_FUNC(setpgrp)
-AC_FUNC_SETPGRP

 if test "$ac_cv_header_shadow_h" = "yes"; then
 	AC_CACHE_CHECK(for working shadow group support,
@@ -196,8 +195,10 @@ AC_DEFINE_UNQUOTED(PASSWD_PROGRAM, "$shadow_cv_passwd_dir/passwd",

 dnl XXX - quick hack, should disappear before anyone notices :).
 AC_DEFINE(USE_SYSLOG, 1, [Define to use syslog().])
-AC_DEFINE(RLOGIN, 1, [Define if login should support the -r flag for rlogind.])
-AC_DEFINE(RUSEROK, 0, [Define to the ruserok() "success" return value (0 or 1).])
+if test "$ac_cv_func_ruserok" = "yes"; then
+	AC_DEFINE(RLOGIN, 1, [Define if login should support the -r flag for rlogind.])
+	AC_DEFINE(RUSEROK, 0, [Define to the ruserok() "success" return value (0 or 1).])
+fi

 AC_ARG_ENABLE(shadowgrp,
 	[AC_HELP_STRING([--enable-shadowgrp], [enable shadow group support @<:@default=yes@:>@])],
@@ -212,8 +213,38 @@ AC_ARG_ENABLE(shadowgrp,
 AC_ARG_ENABLE(man,
 	[AC_HELP_STRING([--enable-man],
 		[regenerate roff man pages from Docbook @<:@default=no@:>@])],
-	[enable_man=yes],
-        [enable_man=no]
+	[enable_man="${enableval}"],
+	[enable_man="no"]
+)
+
+AC_ARG_ENABLE(account-tools-setuid,
+	[AC_HELP_STRING([--enable-account-tools-setuid],
+		[Install the user and group management tools setuid and authenticate the callers. This requires --with-pam.])],
+	[case "${enableval}" in
+	 yes) enable_acct_tools_setuid="yes" ;;
+	  no) enable_acct_tools_setuid="no" ;;
+	   *) AC_MSG_ERROR(bad value ${enableval} for --enable-account-tools-setuid)
+	   ;;
+	 esac],
+	[enable_acct_tools_setuid="maybe"]
+)
+
+AC_ARG_ENABLE(utmpx,
+	[AC_HELP_STRING([--enable-utmpx],
+	                [enable loggin in utmpx / wtmpx @<:@default=no@:>@])],
+	[case "${enableval}" in
+	 yes) enable_utmpx="yes" ;;
+	  no) enable_utmpx="no" ;;
+	   *) AC_MSG_ERROR(bad value ${enableval} for --enable-utmpx) ;;
+	 esac],
+	[enable_utmpx="no"]
+)
+
+AC_ARG_ENABLE(subordinate-ids,
+	[AC_HELP_STRING([--enable-subordinate-ids],
+		[support subordinate ids @<:@default=yes@:>@])],
+	[enable_subids="${enableval}"],
+	[enable_subids="maybe"]
 )

 AC_ARG_WITH(audit, 
@@ -225,19 +256,49 @@ AC_ARG_WITH(libpam,
 AC_ARG_WITH(selinux,
 	[AC_HELP_STRING([--with-selinux], [use SELinux support @<:@default=yes if found@:>@])],
 	[with_selinux=$withval], [with_selinux=maybe])
+AC_ARG_WITH(acl,
+	[AC_HELP_STRING([--with-acl], [use ACL support @<:@default=yes if found@:>@])],
+	[with_acl=$withval], [with_acl=maybe])
+AC_ARG_WITH(attr,
+	[AC_HELP_STRING([--with-attr], [use Extended Attribute support @<:@default=yes if found@:>@])],
+	[with_attr=$withval], [with_attr=maybe])
 AC_ARG_WITH(skey,
 	[AC_HELP_STRING([--with-skey], [use S/Key support @<:@default=no@:>@])],
 	[with_skey=$withval], [with_skey=no])
+AC_ARG_WITH(tcb,
+	[AC_HELP_STRING([--with-tcb], [use tcb support (incomplete) @<:@default=yes if found@:>@])],
+	[with_tcb=$withval], [with_tcb=maybe])
 AC_ARG_WITH(libcrack,
-	[AC_HELP_STRING([--with-libcrack], [use libcrack @<:@default=yes if found and if PAM not enabled@:>@])],
+	[AC_HELP_STRING([--with-libcrack], [use libcrack @<:@default=no@:>@])],
 	[with_libcrack=$withval], [with_libcrack=no])
 AC_ARG_WITH(sha-crypt,
 	[AC_HELP_STRING([--with-sha-crypt], [allow the SHA256 and SHA512 password encryption algorithms @<:@default=yes@:>@])],
 	[with_sha_crypt=$withval], [with_sha_crypt=yes])
+AC_ARG_WITH(nscd,
+	[AC_HELP_STRING([--with-nscd], [enable support for nscd @<:@default=yes@:>@])],
+	[with_nscd=$withval], [with_nscd=yes])
+AC_ARG_WITH(group-name-max-length,
+	[AC_HELP_STRING([--with-group-name-max-length], [set max group name length @<:@default=16@:>@])],
+	[with_group_name_max_length=$withval], [with_group_name_max_length=yes])
+
+if test "$with_group_name_max_length" = "no" ; then
+	with_group_name_max_length=0
+elif test "$with_group_name_max_length" = "yes" ; then
+	with_group_name_max_length=16
+fi
+AC_DEFINE_UNQUOTED(GROUP_NAME_MAX_LENGTH, $with_group_name_max_length, [max group name length])
+AC_SUBST(GROUP_NAME_MAX_LENGTH)
+GROUP_NAME_MAX_LENGTH="$with_group_name_max_length"

 AM_CONDITIONAL(USE_SHA_CRYPT, test "x$with_sha_crypt" = "xyes")
 if test "$with_sha_crypt" = "yes"; then
-		AC_DEFINE(USE_SHA_CRYPT, 1, [Define to allow the SHA256 and SHA512 password encryption algorithms])
+	AC_DEFINE(USE_SHA_CRYPT, 1, [Define to allow the SHA256 and SHA512 password encryption algorithms])
+fi
+
+if test "$with_nscd" = "yes"; then
+	AC_CHECK_FUNC(posix_spawn,
+	              [AC_DEFINE(USE_NSCD, 1, [Define to support flushing of nscd caches])],
+	              [AC_MSG_ERROR([posix_spawn is needed for nscd support])])
 fi

 dnl Check for some functions in libc first, only if not found check for
@@ -268,18 +329,104 @@ if test "$enable_man" = "yes"; then
 	JH_CHECK_XML_CATALOG([http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl],
 		[DocBook XSL Stylesheets >= 1.70.1], [], enable_man=no)
 fi
-AM_CONDITIONAL(ENABLE_REGENERATE_MAN, test x$enable_man != xno)
+AM_CONDITIONAL(ENABLE_REGENERATE_MAN, test "x$enable_man" != "xno")
+
+if test "$enable_subids" != "no"; then
+	dnl
+	dnl FIXME: check if 32 bit UIDs/GIDs are supported by libc
+	dnl
+	AC_RUN_IFELSE([AC_LANG_SOURCE([
+#include <sys/types.h>
+int main(void) {
+	uid_t u;
+	gid_t g;
+	return (sizeof u < 4) || (sizeof g < 4);
+}
+	])], [id32bit="yes"], [id32bit="no"])
+
+	if test "x$id32bit" = "xyes"; then
+		AC_DEFINE(ENABLE_SUBIDS, 1, [Define to support the subordinate IDs.])
+		enable_subids="yes"
+	else
+		if test "x$enable_subids" = "xyes"; then
+			AC_MSG_ERROR([Cannot enable support the subordinate IDs on systems where gid_t or uid_t has less than 32 bits])
+		fi
+		enable_subids="no"
+	fi
+fi
+AM_CONDITIONAL(ENABLE_SUBIDS, test "x$enable_subids" != "xno")

 AC_SUBST(LIBCRYPT)
 AC_CHECK_LIB(crypt, crypt, [LIBCRYPT=-lcrypt],
 	[AC_MSG_ERROR([crypt() not found])])

+AC_SUBST(LIBACL)
+if test "$with_acl" != "no"; then
+	AC_CHECK_HEADERS(acl/libacl.h attr/error_context.h, [acl_header="yes"], [acl_header="no"])
+	if test "$acl_header$with_acl" = "noyes" ; then
+		AC_MSG_ERROR([acl/libacl.h or attr/error_context.h is missing])
+	elif test "$acl_header" = "yes" ; then
+		AC_CHECK_LIB(acl, perm_copy_file,
+		             [AC_CHECK_LIB(acl, perm_copy_fd,
+		                           [acl_lib="yes"],
+		                           [acl_lib="no"])],
+		             [acl_lib="no"])
+		if test "$acl_lib$with_acl" = "noyes" ; then
+			AC_MSG_ERROR([libacl not found])
+		elif test "$acl_lib" = "no" ; then
+			with_acl="no"
+		else
+			AC_DEFINE(WITH_ACL, 1,
+			          [Build shadow with ACL support])
+			LIBACL="-lacl"
+			with_acl="yes"
+		fi
+	else
+		with_acl="no"
+	fi
+fi
+
+AC_SUBST(LIBATTR)
+if test "$with_attr" != "no"; then
+	AC_CHECK_HEADERS(attr/libattr.h attr/error_context.h, [attr_header="yes"], [attr_header="no"])
+	if test "$attr_header$with_attr" = "noyes" ; then
+		AC_MSG_ERROR([attr/libattr.h or attr/error_context.h is missing])
+	elif test "$attr_header" = "yes" ; then
+		AC_CHECK_LIB(attr, attr_copy_file,
+		             [AC_CHECK_LIB(attr, attr_copy_fd,
+		                           [attr_lib="yes"],
+		                           [attr_lib="no"])],
+		             [attr_lib="no"])
+		if test "$attr_lib$with_attr" = "noyes" ; then
+			AC_MSG_ERROR([libattr not found])
+		elif test "$attr_lib" = "no" ; then
+			with_attr="no"
+		else
+			AC_DEFINE(WITH_ATTR, 1,
+			          [Build shadow with Extended Attributes support])
+			LIBATTR="-lattr"
+			with_attr="yes"
+		fi
+	else
+		with_attr="no"
+	fi
+fi
+
 AC_SUBST(LIBAUDIT)
 if test "$with_audit" != "no"; then
 	AC_CHECK_HEADER(libaudit.h, [audit_header="yes"], [audit_header="no"])
 	if test "$audit_header$with_audit" = "noyes" ; then
 		AC_MSG_ERROR([libaudit.h is missing])
 	elif test "$audit_header" = "yes"; then
+		AC_CHECK_DECL(AUDIT_ADD_USER,,[audit_header="no"],[#include <libaudit.h>])
+		AC_CHECK_DECL(AUDIT_DEL_USER,,[audit_header="no"],[#include <libaudit.h>])
+		AC_CHECK_DECL(AUDIT_ADD_GROUP,,[audit_header="no"],[#include <libaudit.h>])
+		AC_CHECK_DECL(AUDIT_DEL_GROUP,,[audit_header="no"],[#include <libaudit.h>])
+		if test "$audit_header$with_audit" = "noyes" ; then
+			AC_MSG_ERROR([AUDIT_ADD_USER AUDIT_DEL_USER AUDIT_ADD_GROUP or AUDIT_DEL_GROUP missing from libaudit.h])
+		fi
+	fi
+	if test "$audit_header" = "yes"; then
 		AC_CHECK_LIB(audit, audit_log_acct_message,
 		             [audit_lib="yes"], [audit_lib="no"])
 		if test "$audit_lib$with_audit" = "noyes" ; then
@@ -309,28 +456,65 @@ if test "$with_libcrack" = "yes"; then
 fi

 AC_SUBST(LIBSELINUX)
+AC_SUBST(LIBSEMANAGE)
 if test "$with_selinux" != "no"; then
 	AC_CHECK_HEADERS(selinux/selinux.h, [selinux_header="yes"], [selinux_header="no"])
 	if test "$selinux_header$with_selinux" = "noyes" ; then
 		AC_MSG_ERROR([selinux/selinux.h is missing])
-	elif test "$selinux_header" = "yes" ; then
-		AC_CHECK_LIB(selinux, is_selinux_enabled,
-		             [selinux_lib="yes"], [selinux_lib="no"])
+	fi
+
+	AC_CHECK_HEADERS(semanage/semanage.h, [semanage_header="yes"], [semanage_header="no"])
+	if test "$semanage_header$with_selinux" = "noyes" ; then
+		AC_MSG_ERROR([semanage/semanage.h is missing])
+	fi
+
+	if test "$selinux_header$semanage_header" = "yesyes" ; then
+		AC_CHECK_LIB(selinux, is_selinux_enabled, [selinux_lib="yes"], [selinux_lib="no"])
 		if test "$selinux_lib$with_selinux" = "noyes" ; then
 			AC_MSG_ERROR([libselinux not found])
-		elif test "$selinux_lib" = "no" ; then
-			with_selinux="no"
-		else
+		fi
+
+		AC_CHECK_LIB(semanage, semanage_connect, [semanage_lib="yes"], [semanage_lib="no"])
+		if test "$semanage_lib$with_selinux" = "noyes" ; then
+			AC_MSG_ERROR([libsemanage not found])
+		fi
+
+		if test "$selinux_lib$semanage_lib" == "yesyes" ; then
 			AC_DEFINE(WITH_SELINUX, 1,
 			          [Build shadow with SELinux support])
 			LIBSELINUX="-lselinux"
+			LIBSEMANAGE="-lsemanage"
 			with_selinux="yes"
+		else
+			with_selinux="no"
 		fi
 	else
 		with_selinux="no"
 	fi
 fi

+AC_SUBST(LIBTCB)
+if test "$with_tcb" != "no"; then
+	AC_CHECK_HEADERS(tcb.h, [tcb_header="yes"], [tcb_header="no"])
+	if test "$tcb_header$with_tcb" = "noyes" ; then
+		AC_MSG_ERROR([tcb.h is missing])
+	elif test "$tcb_header" = "yes" ; then
+		AC_CHECK_LIB(tcb, tcb_is_suspect, [tcb_lib="yes"], [tcb_lib="no"])
+		if test "$tcb_lib$with_tcb" = "noyes" ; then
+			AC_MSG_ERROR([libtcb not found])
+		elif test "$tcb_lib" = "no" ; then
+			with_tcb="no"
+		else
+			AC_DEFINE(WITH_TCB, 1, [Build shadow with tcb support (incomplete)])
+			LIBTCB="-ltcb"
+			with_tcb="yes"
+		fi
+	else
+		with_tcb="no"
+	fi
+fi
+AM_CONDITIONAL(WITH_TCB, test x$with_tcb = xyes)
+
 AC_SUBST(LIBPAM)
 if test "$with_libpam" != "no"; then
 	AC_CHECK_LIB(pam, pam_start,
@@ -339,23 +523,55 @@ if test "$with_libpam" != "no"; then
 		AC_MSG_ERROR(libpam not found)
 	fi

-	AC_CHECK_LIB(pam_misc, main,
-	             [pam_misc_lib="yes"], [pam_misc_lib="no"])
-	if test "$pam_misc_lib$with_libpam" = "noyes" ; then
-		AC_MSG_ERROR(libpam_misc not found)
+	LIBPAM="-lpam"
+	pam_conv_function="no"
+
+	AC_CHECK_LIB(pam, openpam_ttyconv,
+	             [pam_conv_function="openpam_ttyconv"],
+	             AC_CHECK_LIB(pam_misc, misc_conv,
+	                          [pam_conv_function="misc_conv"; LIBPAM="$LIBPAM -lpam_misc"])
+	            )
+
+	if test "$pam_conv_function$with_libpam" = "noyes" ; then
+		AC_MSG_ERROR(PAM conversation function not found)
 	fi

-	if test "$pam_lib$pam_misc_lib" = "yesyes" ; then
+	pam_headers_found=no
+	AC_CHECK_HEADERS( [security/openpam.h security/pam_misc.h],
+	                 [ pam_headers_found=yes ; break ], [],
+	                 [ #include <security/pam_appl.h> ] )
+	if test "$pam_headers_found$with_libpam" = "noyes" ; then
+	                AC_MSG_ERROR(PAM headers not found)
+	fi
+
+
+	if test "$pam_lib$pam_headers_found" = "yesyes" -a "$pam_conv_function" != "no" ; then
 		with_libpam="yes"
 	else
 		with_libpam="no"
+		unset LIBPAM
 	fi
 fi
 dnl Now with_libpam is either yes or no
 if test "$with_libpam" = "yes"; then
+	AC_CHECK_DECLS([PAM_ESTABLISH_CRED,
+	                PAM_DELETE_CRED,
+	                PAM_NEW_AUTHTOK_REQD,
+	                PAM_DATA_SILENT],
+	               [], [], [#include <security/pam_appl.h>])
+
+
+	save_libs=$LIBS
+	LIBS="$LIBS $LIBPAM"
+	# We do not use AC_CHECK_FUNCS to avoid duplicated definition with
+	# Linux PAM.
+	AC_CHECK_FUNC(pam_fail_delay, [AC_DEFINE(HAS_PAM_FAIL_DELAY, 1, [Define to 1 if you have the declaration of 'pam_fail_delay'])])
+	LIBS=$save_libs
+
 	AC_DEFINE(USE_PAM, 1, [Define to support Pluggable Authentication Modules])
+	AC_DEFINE_UNQUOTED(SHADOW_PAM_CONVERSATION, [$pam_conv_function],[PAM converstation to use])
 	AM_CONDITIONAL(USE_PAM, [true])
-	LIBPAM="-lpam -lpam_misc"
+
 	AC_MSG_CHECKING(use login and su access checking if PAM not used)
 	AC_MSG_RESULT(no)
 else
@@ -365,6 +581,24 @@ else
 	AC_MSG_RESULT(yes)
 fi

+if test "$enable_acct_tools_setuid" != "no"; then
+	if test "$with_libpam" != "yes"; then
+		if test "$enable_acct_tools_setuid" = "yes"; then
+			AC_MSG_ERROR(PAM support is required for --enable-account-tools-setuid)
+		else
+			enable_acct_tools_setuid="no"
+		fi
+	else
+		enable_acct_tools_setuid="yes"
+	fi
+	if test "$enable_acct_tools_setuid" = "yes"; then
+		AC_DEFINE(ACCT_TOOLS_SETUID,
+		          1,
+		          [Define if account management tools should be installed setuid and authenticate the callers])
+	fi
+fi
+AM_CONDITIONAL(ACCT_TOOLS_SETUID, test "x$enable_acct_tools_setuid" = "xyes")
+
 AC_SUBST(LIBSKEY)
 AC_SUBST(LIBMD)
 if test "$with_skey" = "yes"; then
@@ -380,6 +614,17 @@ if test "$with_skey" = "yes"; then
 	],[AC_DEFINE(SKEY_BSD_STYLE, 1, [Define to support newer BSD S/Key API])])
 fi

+if test "$enable_utmpx" = "yes"; then
+	if test "$ac_cv_header_utmpx_h" != "yes"; then
+		AC_MSG_ERROR([The utmpx.h header file is required for utmpx support.])
+	fi
+	AC_DEFINE(USE_UTMPX,
+	          1,
+	          [Define if utmpx should be used])
+fi
+
+AC_DEFINE_UNQUOTED(SHELL, ["$SHELL"], [The default shell.])
+
 AM_GNU_GETTEXT_VERSION(0.16)
 AM_GNU_GETTEXT([external], [need-ngettext])
 AM_CONDITIONAL(USE_NLS, test "x$USE_NLS" = "xyes")
@@ -389,8 +634,10 @@ AC_CONFIG_FILES([
 	po/Makefile.in
 	doc/Makefile
 	man/Makefile
-	man/po/Makefile.in
+	man/config.xml
+	man/po/Makefile
 	man/cs/Makefile
+	man/da/Makefile
 	man/de/Makefile
 	man/es/Makefile
 	man/fi/Makefile
@@ -423,8 +670,16 @@ echo
 echo "	auditing support:		$with_audit"
 echo "	CrackLib support:		$with_libcrack"
 echo "	PAM support:			$with_libpam"
+if test "$with_libpam" = "yes"; then
+echo "	suid account management tools:	$enable_acct_tools_setuid"
+fi
 echo "	SELinux support:		$with_selinux"
+echo "	ACL support:			$with_acl"
+echo "	Extended Attributes support:	$with_attr"
+echo "	tcb support (incomplete):	$with_tcb"
 echo "	shadow group support:		$enable_shadowgrp"
 echo "	S/Key support:			$with_skey"
 echo "	SHA passwords encryption:	$with_sha_crypt"
+echo "	nscd support:			$with_nscd"
+echo "	subordinate IDs support:	$enable_subids"
 echo
--- a/contrib/adduser-old.c
+++ b/contrib/adduser-old.c
@@ -230,7 +230,7 @@ void main()
 			fflush(stdin);
 		} else
 			if (dir[strlen(dir)-1]=='/')
-				sprintf(dir,"%s%s",dir,uname);
+				sprintf(dir+strlen(dir),"%s",uname);

 		printf("\nShell [%s]: ",DEFAULT_SHELL);
 		fflush(stdout);
--- a/contrib/adduser.c
+++ b/contrib/adduser.c
@@ -296,7 +296,7 @@ main (void)
 	      sprintf (dir, "%s/%s", DEFAULT_HOME, usrname);
 	    }
 	  else if (dir[strlen (dir) - 1] == '/')
-	    sprintf (dir, "%s%s", dir, usrname);
+	    sprintf (dir+strlen(dir), "%s", usrname);
 	}
      else
 	{
--- a/doc/WISHLIST
+++ b/doc/WISHLIST
@@ -31,8 +31,6 @@ New ideas to add to this list are welcome, too.  --marekm
 - new option for /etc/suauth: don't load user's environment (force "su -")
  suggested by Ulisses Alonso Camaro
 - find out why recent releases won't compile on Solaris
- newusers UID/GID selection algorithm should be the same as useradd
-  (and use UID_MIN, UID_MAX from login.defs)
 - newusers should be able to copy /etc/skel to the new home directory
  (like useradd)
 - add directories where other packages can add hooks for package-specific
--- a/etc/login.defs
+++ b/etc/login.defs
@@ -6,16 +6,18 @@

 #
 # Delay in seconds before being allowed another attempt after a login failure
+# Note: When PAM is used, some modules may enforce a minimum delay (e.g.
+#       pam_unix(8) enforces a 2s delay)
 #
 FAIL_DELAY		3

 #
-# Enable logging and display of /var/log/faillog login failure info.
+# Enable logging and display of /var/log/faillog login(1) failure info.
 #
 FAILLOG_ENAB		yes

 #
-# Enable display of unknown usernames when login failures are recorded.
+# Enable display of unknown usernames when login(1) failures are recorded.
 #
 LOG_UNKFAIL_ENAB	no

@@ -25,7 +27,7 @@ LOG_UNKFAIL_ENAB	no
 LOG_OK_LOGINS		no

 #
-# Enable logging and display of /var/log/lastlog login time info.
+# Enable logging and display of /var/log/lastlog login(1) time info.
 #
 LASTLOG_ENAB		yes

@@ -48,13 +50,13 @@ OBSCURE_CHECKS_ENAB	yes
 PORTTIME_CHECKS_ENAB	yes

 #
-# Enable setting of ulimit, umask, and niceness from passwd gecos field.
+# Enable setting of ulimit, umask, and niceness from passwd(5) gecos field.
 #
 QUOTAS_ENAB		yes

 #
-# Enable "syslog" logging of su activity - in addition to sulog file logging.
-# SYSLOG_SG_ENAB does the same for newgrp and sg.
+# Enable "syslog" logging of su(1) activity - in addition to sulog file logging.
+# SYSLOG_SG_ENAB does the same for newgrp(1) and sg(1).
 #
 SYSLOG_SU_ENAB		yes
 SYSLOG_SG_ENAB		yes
@@ -62,13 +64,13 @@ SYSLOG_SG_ENAB		yes
 #
 # If defined, either full pathname of a file containing device names or
 # a ":" delimited list of device names.  Root logins will be allowed only
-# upon these devices.
+# from these devices.
 #
 CONSOLE		/etc/securetty
 #CONSOLE	console:tty01:tty02:tty03:tty04

 #
-# If defined, all su activity is logged to this file.
+# If defined, all su(1) activity is logged to this file.
 #
 #SULOG_FILE	/var/log/sulog

@@ -80,33 +82,33 @@ MOTD_FILE	/etc/motd
 #MOTD_FILE	/etc/motd:/usr/lib/news/news-motd

 #
-# If defined, this file will be output before each login prompt.
+# If defined, this file will be output before each login(1) prompt.
 #
 #ISSUE_FILE	/etc/issue

 #
 # If defined, file which maps tty line to TERM environment parameter.
-# Each line of the file is in a format something like "vt100  tty01".
+# Each line of the file is in a format similar to "vt100  tty01".
 #
 #TTYTYPE_FILE	/etc/ttytype

 #
-# If defined, login failures will be logged here in a utmp format.
-# last, when invoked as lastb, will read /var/log/btmp, so...
+# If defined, login(1) failures will be logged here in a utmp format.
+# last(1), when invoked as lastb(1), will read /var/log/btmp, so...
 #
 FTMP_FILE	/var/log/btmp

 #
-# If defined, name of file whose presence which will inhibit non-root
-# logins.  The contents of this file should be a message indicating
+# If defined, name of file whose presence will inhibit non-root
+# logins.  The content of this file should be a message indicating
 # why logins are inhibited.
 #
 NOLOGINS_FILE	/etc/nologin

 #
 # If defined, the command name to display when running "su -".  For
-# example, if this is defined as "su" then a "ps" will display the
-# command is "-su".  If not defined, then "ps" would display the
+# example, if this is defined as "su" then ps(1) will display the
+# command as "-su".  If not defined, then ps(1) will display the
 # name of the shell actually being run, e.g. something like "-sh".
 #
 SU_NAME		su
@@ -156,10 +158,10 @@ ENV_PATH	PATH=/bin:/usr/bin
 #	TTYGROUP	Login tty will be assigned this group ownership.
 #	TTYPERM		Login tty will be set to this permission.
 #
-# If you have a "write" program which is "setgid" to a special group
-# which owns the terminals, define TTYGROUP to the group number and
-# TTYPERM to 0620.  Otherwise leave TTYGROUP commented out and assign
-# TTYPERM to either 622 or 600.
+# If you have a write(1) program which is "setgid" to a special group
+# which owns the terminals, define TTYGROUP as the number of such group
+# and TTYPERM as 0620.  Otherwise leave TTYGROUP commented out and
+# set TTYPERM to either 622 or 600.
 #
 TTYGROUP	tty
 TTYPERM		0600
@@ -169,7 +171,6 @@ TTYPERM		0600
 #
 #	ERASECHAR	Terminal ERASE character ('\010' = backspace).
 #	KILLCHAR	Terminal KILL character ('\025' = CTRL/U).
-#	UMASK		Default "umask" value.
 #	ULIMIT		Default "ulimit" value.
 #
 # The ERASECHAR and KILLCHAR are used only on System V machines.
@@ -180,9 +181,17 @@ TTYPERM		0600
 #
 ERASECHAR	0177
 KILLCHAR	025
-UMASK		022
 #ULIMIT		2097152

+# Default initial "umask" value used by login(1) on non-PAM enabled systems.
+# Default "umask" value for pam_umask(8) on PAM enabled systems.
+# UMASK is also used by useradd(8) and newusers(8) to set the mode for new
+# home directories.
+# 022 is the default value, but 027, or even 077, could be considered
+# for increased privacy. There is no One True Answer here: each sysadmin
+# must make up his/her mind.
+UMASK		022
+
 #
 # Password aging controls:
 #
@@ -205,35 +214,43 @@ PASS_WARN_AGE	7
 SU_WHEEL_ONLY	no

 #
-# If compiled with cracklib support, where are the dictionaries
+# If compiled with cracklib support, sets the path to the dictionaries
 #
 CRACKLIB_DICTPATH	/var/cache/cracklib/cracklib_dict

 #
-# Min/max values for automatic uid selection in useradd
+# Min/max values for automatic uid selection in useradd(8)
 #
 UID_MIN			 1000
 UID_MAX			60000
 # System accounts
-SYS_UID_MIN		  100
+SYS_UID_MIN		  101
 SYS_UID_MAX		  999
+# Extra per user uids
+SUB_UID_MIN		   100000
+SUB_UID_MAX		600100000
+SUB_UID_COUNT		    10000

 #
-# Min/max values for automatic gid selection in groupadd
+# Min/max values for automatic gid selection in groupadd(8)
 #
 GID_MIN			 1000
 GID_MAX			60000
 # System accounts
-SYS_GID_MIN		  100
+SYS_GID_MIN		  101
 SYS_GID_MAX		  999
+# Extra per user group ids
+SUB_GID_MIN		   100000
+SUB_GID_MAX		600100000
+SUB_GID_COUNT		    10000

 #
-# Max number of login retries if password is bad
+# Max number of login(1) retries if password is bad
 #
 LOGIN_RETRIES		5

 #
-# Max time in seconds for login
+# Max time in seconds for login(1)
 #
 LOGIN_TIMEOUT		60

@@ -255,12 +272,12 @@ PASS_ALWAYS_WARN	yes
 #PASS_MAX_LEN		8

 #
-# Require password before chfn/chsh can make any changes.
+# Require password before chfn(1)/chsh(1) can make any changes.
 #
 CHFN_AUTH		yes

 #
-# Which fields may be changed by regular users using chfn - use
+# Which fields may be changed by regular users using chfn(1) - use
 # any combination of letters "frwh" (full name, room number, work
 # phone, home phone).  If not defined, no changes are allowed.
 # For backward compatibility, "yes" = "rwh" and "no" = "frwh".
@@ -285,13 +302,13 @@ CHFN_RESTRICT		rwh
 # Note: If you use PAM, it is recommended to use a value consistent with
 # the PAM modules configuration.
 #
-# This variable is deprecated. You should use ENCRYPT_METHOD.
+# This variable is deprecated. You should use ENCRYPT_METHOD instead.
 #
 #MD5_CRYPT_ENAB	no

 #
 # Only works if compiled with ENCRYPTMETHOD_SELECT defined:
-# If set to MD5 , MD5-based algorithm will be used for encrypting password
+# If set to MD5, MD5-based algorithm will be used for encrypting password
 # If set to SHA256, SHA256-based algorithm will be used for encrypting password
 # If set to SHA512, SHA512-based algorithm will be used for encrypting password
 # If set to DES, DES-based algorithm will be used for encrypting password (default)
@@ -306,12 +323,12 @@ CHFN_RESTRICT		rwh
 # Only works if ENCRYPT_METHOD is set to SHA256 or SHA512.
 #
 # Define the number of SHA rounds.
-# With a lot of rounds, it is more difficult to brute forcing the password.
-# But note also that it more CPU resources will be needed to authenticate
-# users.
+# With a lot of rounds, it is more difficult to brute-force the password.
+# However, more CPU resources will be needed to authenticate users if
+# this value is increased.
 #
 # If not specified, the libc will choose the default number of rounds (5000).
-# The values must be inside the 1000-999999999 range.
+# The values must be within the 1000-999999999 range.
 # If only one of the MIN or MAX values is set, then this value will be used.
 # If MIN > MAX, the highest value will be used.
 #
@@ -320,18 +337,18 @@ CHFN_RESTRICT		rwh

 #
 # List of groups to add to the user's supplementary group set
-# when logging in on the console (as determined by the CONSOLE
+# when logging in from the console (as determined by the CONSOLE
 # setting).  Default is none.
 #
 # Use with caution - it is possible for users to gain permanent
-# access to these groups, even when not logged in on the console.
+# access to these groups, even when not logged in from the console.
 # How to do it is left as an exercise for the reader...
 #
 #CONSOLE_GROUPS		floppy:audio:cdrom

 #
 # Should login be allowed if we can't cd to the home directory?
-# Default in no.
+# Default is no.
 #
 DEFAULT_HOME	yes

@@ -353,17 +370,26 @@ ENVIRON_FILE	/etc/environment
 # (examples: 022 -> 002, 077 -> 007) for non-root users, if the uid is
 # the same as gid, and username is the same as the primary group name.
 #
-# This also enables userdel to remove user groups if no members exist.
+# This also enables userdel(8) to remove user groups if no members exist.
 #
 USERGROUPS_ENAB yes

 #
-# If set to a non-nul number, the shadow utilities will make sure that
+# If set to a non-zero number, the shadow utilities will make sure that
 # groups never have more than this number of users on one line.
-# This permit to support split groups (groups split into multiple lines,
+# This permits to support split groups (groups split into multiple lines,
 # with the same group ID, to avoid limitation of the line length in the
 # group file).
 #
 # 0 is the default value and disables this feature.
 #
 #MAX_MEMBERS_PER_GROUP	0
+
+#
+# If useradd(8) should create home directories for users by default (non
+# system users only).
+# This option is overridden with the -M or -m flags on the useradd(8)
+# command-line.
+#
+#CREATE_HOME     yes
+
--- a/etc/pam.d/Makefile.am
+++ b/etc/pam.d/Makefile.am
@@ -2,19 +2,21 @@
 # and also cooperate to make a distribution for `make dist'

 pamd_files = \
-	chage \
 	chfn \
+	chsh \
+	groupmems \
+	login \
+	passwd \
+	su
+
+pamd_acct_tools_files = \
+	chage \
 	chgpasswd \
 	chpasswd \
-	chsh \
 	groupadd \
 	groupdel \
-	groupmems \
 	groupmod \
-	login \
 	newusers \
-	passwd \
-	su \
 	useradd \
 	userdel \
 	usermod
@@ -22,6 +24,9 @@ pamd_files = \
 if USE_PAM
 pamddir = $(sysconfdir)/pam.d
 pamd_DATA = $(pamd_files)
+if ACCT_TOOLS_SETUID
+pamd_DATA += $(pamd_acct_tools_files)
+endif
 endif

-EXTRA_DIST = $(pamd_files)
+EXTRA_DIST = $(pamd_files) $(pamd_acct_tools_files)
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -14,9 +14,15 @@ libshadow_la_SOURCES = \
 	encrypt.c \
 	exitcodes.h \
 	faillog.h \
+	fields.c \
 	fputsx.c \
 	getdef.c \
 	getdef.h \
+	get_gid.c \
+	getlong.c \
+	get_pid.c \
+	get_uid.c \
+	getulong.c \
 	groupio.c \
 	groupmem.c \
 	groupio.h \
@@ -33,16 +39,26 @@ libshadow_la_SOURCES = \
 	pwio.c \
 	pwio.h \
 	pwmem.c \
+	subordinateio.h \
+	subordinateio.c \
+	selinux.c \
+	semanage.c \
 	sgetgrent.c \
 	sgetpwent.c \
+	sgetspent.c \
 	sgroupio.c \
 	sgroupio.h\
 	shadow.c \
 	shadowio.c \
 	shadowio.h \
 	shadowmem.c \
+	spawn.c \
 	utent.c

+if WITH_TCB
+libshadow_la_SOURCES += tcbfuncs.c tcbfuncs.h
+endif
+
 # These files are unneeded for some reason, listed in
 # order of appearance:
 #
--- a/lib/commonio.c
+++ b/lib/commonio.c
--- a/lib/commonio.h
+++ b/lib/commonio.h
@@ -2,7 +2,7 @@
 * Copyright (c) 1990 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -37,14 +37,18 @@
 #ifdef WITH_SELINUX
 #include <selinux/selinux.h>
 #endif
+
+#include "defines.h" /* bool */
+
 /*
 * Linked list entry.
 */
 struct commonio_entry {
-	char *line;
-	void *eptr;		/* struct passwd, struct spwd, ... */
-	struct commonio_entry *prev, *next;
-	unsigned int changed:1;
+	/*@null@*/char *line;
+	/*@null@*/void *eptr;		/* struct passwd, struct spwd, ... */
+	/*@dependent@*/ /*@null@*/struct commonio_entry *prev;
+	/*@owned@*/ /*@null@*/struct commonio_entry *next;
+	bool changed:1;
 };

 /*
@@ -55,12 +59,12 @@ struct commonio_ops {
 	 * Make a copy of the object (for example, struct passwd)
 	 * and all strings pointed by it, in malloced memory.
 	 */
-	void *(*dup) (const void *);
+	/*@null@*/ /*@only@*/void *(*dup) (const void *);

 	/*
 	 * free() the object including any strings pointed by it.
 	 */
-	void (*free) (void *);
+	void (*free) (/*@out@*/ /*@only@*/void *);

 	/*
 	 * Return the name of the object (for example, pw_name
@@ -84,7 +88,7 @@ struct commonio_ops {
 	 * fgets and fputs (can be replaced by versions that
 	 * understand line continuation conventions).
 	 */
-	char *(*fgets) (char *, int, FILE *);
+	/*@null@*/char *(*fgets) (/*@returned@*/ /*@out@*/char *s, int n, FILE *stream);
 	int (*fputs) (const char *, FILE *);

 	/*
@@ -93,8 +97,8 @@ struct commonio_ops {
 	 * is open or before it is closed.
 	 * They return 0 on failure and 1 on success.
 	 */
-	int (*open_hook) (void);
-	int (*close_hook) (void);
+	/*@null@*/int (*open_hook) (void);
+	/*@null@*/int (*close_hook) (void);
 };

 /*
@@ -109,47 +113,52 @@ struct commonio_db {
 	/*
 	 * Operations from above.
 	 */
-	struct commonio_ops *ops;
+	/*@observer@*/const struct commonio_ops *ops;

 	/*
 	 * Currently open file stream.
 	 */
-	FILE *fp;
+	/*@dependent@*/ /*@null@*/FILE *fp;

 #ifdef WITH_SELINUX
-	security_context_t scontext;
+	/*@null@*/security_context_t scontext;
 #endif
 	/*
 	 * Head, tail, current position in linked list.
 	 */
-	struct commonio_entry *head, *tail, *cursor;
+	/*@owned@*/ /*@null@*/struct commonio_entry *head;
+	/*@dependent@*/ /*@null@*/struct commonio_entry *tail;
+	/*@dependent@*/ /*@null@*/struct commonio_entry *cursor;

 	/*
 	 * Various flags.
 	 */
-	unsigned int changed:1;
-	unsigned int isopen:1;
-	unsigned int locked:1;
-	unsigned int readonly:1;
+	bool changed:1;
+	bool isopen:1;
+	bool locked:1;
+	bool readonly:1;
 };

 extern int commonio_setname (struct commonio_db *, const char *);
-extern int commonio_present (const struct commonio_db *);
+extern bool commonio_present (const struct commonio_db *db);
 extern int commonio_lock (struct commonio_db *);
-extern int commonio_lock_nowait (struct commonio_db *);
+extern int commonio_lock_nowait (struct commonio_db *, bool log);
 extern int commonio_open (struct commonio_db *, int);
-extern const void *commonio_locate (struct commonio_db *, const char *);
+extern /*@observer@*/ /*@null@*/const void *commonio_locate (struct commonio_db *, const char *);
 extern int commonio_update (struct commonio_db *, const void *);
+#ifdef ENABLE_SUBIDS
+extern int commonio_append (struct commonio_db *, const void *);
+#endif				/* ENABLE_SUBIDS */
 extern int commonio_remove (struct commonio_db *, const char *);
 extern int commonio_rewind (struct commonio_db *);
-extern const void *commonio_next (struct commonio_db *);
+extern /*@observer@*/ /*@null@*/const void *commonio_next (struct commonio_db *);
 extern int commonio_close (struct commonio_db *);
 extern int commonio_unlock (struct commonio_db *);
 extern void commonio_del_entry (struct commonio_db *,
-				const struct commonio_entry *);
+                                const struct commonio_entry *);
 extern int commonio_sort_wrt (struct commonio_db *shadow,
-			      struct commonio_db *passwd);
+                              const struct commonio_db *passwd);
 extern int commonio_sort (struct commonio_db *db,
-			  int (*cmp) (const void *, const void *));
+                          int (*cmp) (const void *, const void *));

 #endif
--- a/lib/defines.h
+++ b/lib/defines.h
@@ -4,29 +4,60 @@
 #ifndef _DEFINES_H_
 #define _DEFINES_H_

+#if HAVE_STDBOOL_H
+# include <stdbool.h>
+#else
+# if ! HAVE__BOOL
+#  ifdef __cplusplus
+typedef bool _Bool;
+#  else
+typedef unsigned char _Bool;
+#  endif
+# endif
+# define bool _Bool
+# define false (0)
+# define true  (1)
+# define __bool_true_false_are_defined 1
+#endif
+
 #define ISDIGIT_LOCALE(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))

 /* Take care of NLS matters.  */
-
-#if HAVE_LOCALE_H
+#ifdef S_SPLINT_S
+extern char *setlocale(int categorie, const char *locale);
+# define LC_ALL		(6)
+extern char * bindtextdomain (const char * domainname, const char * dirname);
+extern char * textdomain (const char * domainname);
+# define _(Text) Text
+# define ngettext(Msgid1, Msgid2, N) \
+    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
+#else
+#ifdef HAVE_LOCALE_H
 # include <locale.h>
+#else
+# undef setlocale
+# define setlocale(category, locale)	(NULL)
+# ifndef LC_ALL
+#  define LC_ALL	6
+# endif
 #endif

 #define gettext_noop(String) (String)
 /* #define gettext_def(String) "#define String" */

-#if ENABLE_NLS
+#ifdef ENABLE_NLS
 # include <libintl.h>
 # define _(Text) gettext (Text)
 #else
 # undef bindtextdomain
-# define bindtextdomain(Domain, Directory)	/* empty */
+# define bindtextdomain(Domain, Directory)	(NULL)
 # undef textdomain
-# define textdomain(Domain)	/* empty */
+# define textdomain(Domain)	(NULL)
 # define _(Text) Text
 # define ngettext(Msgid1, Msgid2, N) \
    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
 #endif
+#endif

 #if STDC_HEADERS
 # include <stdlib.h>
@@ -136,7 +167,7 @@ char *strchr (), *strrchr (), *strtok ();

 /* cleaner than lots of #ifdefs everywhere - use this as follows:
   SYSLOG((LOG_CRIT, "user %s cracked root", user)); */
-#if ENABLE_NLS
+#ifdef ENABLE_NLS
 /* Temporarily set LC_TIME to "C" to avoid strange dates in syslog.
   This is a workaround for a more general syslog(d) design problem -
   syslogd should log the current system time for each event, and not
@@ -146,17 +177,20 @@ char *strchr (), *strrchr (), *strtok ();
 * --Nekral */
 #define SYSLOG(x)							\
 	do {								\
-		char *saved_locale = setlocale(LC_ALL, NULL);		\
-		if (saved_locale)					\
-			saved_locale = strdup(saved_locale);		\
-		if (saved_locale)					\
-			setlocale(LC_ALL, "C");			\
-		syslog x ;						\
-		if (saved_locale) {					\
-			setlocale(LC_ALL, saved_locale);		\
-			free(saved_locale);				\
+		char *old_locale = setlocale (LC_ALL, NULL);		\
+		char *saved_locale = NULL;				\
+		if (NULL != old_locale) {				\
+			saved_locale = strdup (old_locale);		\
 		}							\
-	} while (0)
+		if (NULL != saved_locale) {				\
+			(void) setlocale (LC_ALL, "C");			\
+		}							\
+		syslog x ;						\
+		if (NULL != saved_locale) {				\
+			(void) setlocale (LC_ALL, saved_locale);	\
+			free (saved_locale);				\
+		}							\
+	} while (false)
 #else				/* !ENABLE_NLS */
 #define SYSLOG(x) syslog x
 #endif				/* !ENABLE_NLS */
@@ -303,6 +337,8 @@ extern char *strerror ();
 #define SHADOW_PASSWD_STRING "x"
 #endif

+#define SHADOW_SP_FLAG_UNSET ((unsigned long int)-1)
+
 #ifdef WITH_AUDIT
 #ifdef __u8			/* in case we use pam < 0.80 */
 #undef __u8
@@ -321,4 +357,29 @@ extern char *strerror ();
 # define unused
 #endif

+/* ! Arguments evaluated twice ! */
+#ifndef MIN
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+#ifndef MAX
+#define MAX(x,y) (((x) > (y)) ? (x) : (y))
+#endif
+
+/* Maximum length of usernames */
+#ifdef HAVE_UTMPX_H
+# include <utmpx.h>
+# define USER_NAME_MAX_LENGTH (sizeof (((struct utmpx *)NULL)->ut_user))
+#else
+# include <utmp.h>
+# ifdef HAVE_STRUCT_UTMP_UT_USER
+#  define USER_NAME_MAX_LENGTH (sizeof (((struct utmp *)NULL)->ut_user))
+# else
+#  ifdef HAVE_STRUCT_UTMP_UT_NAME
+#   define USER_NAME_MAX_LENGTH (sizeof (((struct utmp *)NULL)->ut_name))
+#  else
+#   define USER_NAME_MAX_LENGTH 32
+#  endif
+# endif
+#endif
+
 #endif				/* _DEFINES_H_ */
--- a/lib/encrypt.c
+++ b/lib/encrypt.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1990 - 1993, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -40,27 +40,26 @@
 #include "prototypes.h"
 #include "defines.h"

-char *pw_encrypt (const char *clear, const char *salt)
+/*@exposed@*//*@null@*/char *pw_encrypt (const char *clear, const char *salt)
 {
 	static char cipher[128];
 	char *cp;

 	cp = crypt (clear, salt);
-	if (!cp) {
+	if (NULL == cp) {
 		/*
 		 * Single Unix Spec: crypt() may return a null pointer,
-		 * and set errno to indicate an error.  The caller doesn't
-		 * expect us to return NULL, so...
+		 * and set errno to indicate an error. In this case return
+		 * the NULL so the caller can handle appropriately.
 		 */
-		perror ("crypt");
-		exit (1);
+		return NULL;
 	}

-	/* The GNU crypt does not return NULL if the algorithm is not
+	/* Some crypt() do not return NULL if the algorithm is not
 	 * supported, and return a DES encrypted password. */
-	if (salt && salt[0] == '$' && strlen (cp) <= 13)
+	if ((NULL != salt) && (salt[0] == '$') && (strlen (cp) <= 13))
 	{
-		const char *method;
+		/*@observer@*/const char *method;
 		switch (salt[1])
 		{
 			case '1':
@@ -79,15 +78,18 @@ char *pw_encrypt (const char *clear, const char *salt)
 				method = &nummethod[0];
 			}
 		}
-		fprintf (stderr,
-			 _("crypt method not supported by libcrypt? (%s)\n"),
-			  method);
-		exit (1);
+		(void) fprintf (stderr,
+		                _("crypt method not supported by libcrypt? (%s)\n"),
+		                method);
+		exit (EXIT_FAILURE);
 	}

-	if (strlen (cp) != 13)
+	if (strlen (cp) != 13) {
 		return cp;	/* nonstandard crypt() in libc, better bail out */
+	}
+
 	strcpy (cipher, cp);

 	return cipher;
 }
+
--- a/lib/exitcodes.h
+++ b/lib/exitcodes.h
@@ -32,7 +32,12 @@
 /*
 * Exit codes used by shadow programs
 */
-#define E_SUCCESS       	0	/* success */
+#define E_SUCCESS       	EXIT_SUCCESS	/* success */
+/*
+ * FIXME: other values should differ from EXIT_FAILURE (and EXIT_SUCCESS).
+ *
+ * FIXME: reserve EXIT_FAILURE for internal failures.
+ */
 #define E_NOPERM        	1	/* permission denied */
 #define E_USAGE         	2	/* invalid command syntax */
 #define E_BAD_ARG       	3	/* invalid argument to option */
--- a/libmisc/fields.c
+++ b/libmisc/fields.c
@@ -54,6 +54,10 @@ int valid_field (const char *field, const char *illegal)
 	const char *cp;
 	int err = 0;

+	if (NULL == field) {
+		return -1;
+	}
+
 	/* For each character of field, search if it appears in the list
 	 * of illegal characters. */
 	for (cp = field; '\0' != *cp; cp++) {
--- a/lib/fputsx.c
+++ b/lib/fputsx.c
@@ -39,23 +39,29 @@
 #ident "$Id$"


-char *fgetsx (char *buf, int cnt, FILE * f)
+/*@null@*/char *fgetsx (/*@returned@*/ /*@out@*/char *buf, int cnt, FILE * f)
 {
 	char *cp = buf;
 	char *ep;

 	while (cnt > 0) {
-		if (fgets (cp, cnt, f) == 0) {
-			if (cp == buf)
+		if (fgets (cp, cnt, f) != cp) {
+			if (cp == buf) {
 				return 0;
-			else
+			} else {
 				break;
+			}
 		}
-		if ((ep = strrchr (cp, '\\')) && *(ep + 1) == '\n') {
-			if ((cnt -= ep - cp) > 0)
-				*(cp = ep) = '\0';
-		} else
+		ep = strrchr (cp, '\\');
+		if ((NULL != ep) && (*(ep + 1) == '\n')) {
+			cnt -= ep - cp;
+			if (cnt > 0) {
+				cp = ep;
+				*cp = '\0';
+			}
+		} else {
 			break;
+		}
 	}
 	return buf;
 }
@@ -64,9 +70,10 @@ int fputsx (const char *s, FILE * stream)
 {
 	int i;

-	for (i = 0; *s; i++, s++) {
-		if (putc (*s, stream) == EOF)
+	for (i = 0; '\0' != *s; i++, s++) {
+		if (putc (*s, stream) == EOF) {
 			return EOF;
+		}

 #if 0				/* The standard getgr*() can't handle that.  --marekm */
 		if (i > (BUFSIZ / 2)) {
@@ -80,3 +87,4 @@ int fputsx (const char *s, FILE * stream)
 	}
 	return 0;
 }
+
--- a/lib/get_gid.c
+++ b/lib/get_gid.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2009       , Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id$"
+
+#include "prototypes.h"
+#include "defines.h"
+
+int get_gid (const char *gidstr, gid_t *gid)
+{
+	long long int val;
+	char *endptr;
+
+	errno = 0;
+	val = strtoll (gidstr, &endptr, 10);
+	if (   ('\0' == *gidstr)
+	    || ('\0' != *endptr)
+	    || (ERANGE == errno)
+	    || (/*@+longintegral@*/val != (gid_t)val)/*@=longintegral@*/) {
+		return 0;
+	}
+
+	*gid = (gid_t)val;
+	return 1;
+}
+
--- a/lib/get_pid.c
+++ b/lib/get_pid.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2009       , Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id$"
+
+#include "prototypes.h"
+#include "defines.h"
+
+int get_pid (const char *pidstr, pid_t *pid)
+{
+	long long int val;
+	char *endptr;
+
+	errno = 0;
+	val = strtoll (pidstr, &endptr, 10);
+	if (   ('\0' == *pidstr)
+	    || ('\0' != *endptr)
+	    || (ERANGE == errno)
+	    || (/*@+longintegral@*/val != (pid_t)val)/*@=longintegral@*/) {
+		return 0;
+	}
+
+	*pid = (pid_t)val;
+	return 1;
+}
+
--- a/lib/get_uid.c
+++ b/lib/get_uid.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2009       , Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id$"
+
+#include "prototypes.h"
+#include "defines.h"
+
+int get_uid (const char *uidstr, uid_t *uid)
+{
+	long long int val;
+	char *endptr;
+
+	errno = 0;
+	val = strtoll (uidstr, &endptr, 10);
+	if (   ('\0' == *uidstr)
+	    || ('\0' != *endptr)
+	    || (ERANGE == errno)
+	    || (/*@+longintegral@*/val != (uid_t)val)/*@=longintegral@*/) {
+		return 0;
+	}
+
+	*uid = (uid_t)val;
+	return 1;
+}
+
--- a/lib/getdef.c
+++ b/lib/getdef.c
@@ -39,13 +39,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
+#include <errno.h>
 #include "getdef.h"
 /*
 * A configuration item definition.
 */
 struct itemdef {
-	const char *name;	/* name of the item                     */
-	char *value;		/* value given, or NULL if no value     */
+	/*@null@*/const char *name;	/* name of the item                     */
+	/*@null@*/char *value;		/* value given, or NULL if no value     */
 };

 #define NUMDEFS	(sizeof(def_table)/sizeof(def_table[0]))
@@ -80,6 +81,12 @@ static struct itemdef def_table[] = {
 	{"SHA_CRYPT_MAX_ROUNDS", NULL},
 	{"SHA_CRYPT_MIN_ROUNDS", NULL},
 #endif
+	{"SUB_GID_COUNT", NULL},
+	{"SUB_GID_MAX", NULL},
+	{"SUB_GID_MIN", NULL},
+	{"SUB_UID_COUNT", NULL},
+	{"SUB_UID_MAX", NULL},
+	{"SUB_UID_MIN", NULL},
 	{"SULOG_FILE", NULL},
 	{"SU_NAME", NULL},
 	{"SYS_GID_MAX", NULL},
@@ -122,6 +129,11 @@ static struct itemdef def_table[] = {
 #ifdef USE_SYSLOG
 	{"SYSLOG_SG_ENAB", NULL},
 	{"SYSLOG_SU_ENAB", NULL},
+#endif
+#ifdef WITH_TCB
+	{"TCB_AUTH_GROUP", NULL},
+	{"TCB_SYMLINKS", NULL},
+	{"USE_TCB", NULL},
 #endif
 	{NULL, NULL}
 };
@@ -131,10 +143,10 @@ static struct itemdef def_table[] = {
 #endif

 static char def_fname[] = LOGINDEFS;	/* login config defs file       */
-static int def_loaded = 0;	/* are defs already loaded?     */
+static bool def_loaded = false;		/* are defs already loaded?     */

 /* local function prototypes */
-static struct itemdef *def_find (const char *);
+static /*@observer@*/ /*@null@*/struct itemdef *def_find (const char *);
 static void def_load (void);


@@ -145,14 +157,16 @@ static void def_load (void);
 * defined.  First time invoked, will load definitions from the file.
 */

-char *getdef_str (const char *item)
+/*@observer@*/ /*@null@*/const char *getdef_str (const char *item)
 {
 	struct itemdef *d;

-	if (!def_loaded)
+	if (!def_loaded) {
 		def_load ();
+	}

-	return ((d = def_find (item)) == NULL ? (char *) NULL : d->value);
+	d = def_find (item);
+	return ((NULL == d)? (const char *) NULL : d->value);
 }


@@ -162,15 +176,18 @@ char *getdef_str (const char *item)
 * Return TRUE if specified item is defined as "yes", else FALSE.
 */

-int getdef_bool (const char *item)
+bool getdef_bool (const char *item)
 {
 	struct itemdef *d;

-	if (!def_loaded)
+	if (!def_loaded) {
 		def_load ();
+	}

-	if ((d = def_find (item)) == NULL || d->value == NULL)
-		return 0;
+	d = def_find (item);
+	if ((NULL == d) || (NULL == d->value)) {
+		return false;
+	}

 	return (strcasecmp (d->value, "yes") == 0);
 }
@@ -187,14 +204,27 @@ int getdef_bool (const char *item)
 int getdef_num (const char *item, int dflt)
 {
 	struct itemdef *d;
+	long val;

-	if (!def_loaded)
+	if (!def_loaded) {
 		def_load ();
+	}

-	if ((d = def_find (item)) == NULL || d->value == NULL)
+	d = def_find (item);
+	if ((NULL == d) || (NULL == d->value)) {
 		return dflt;
+	}

-	return (int) strtol (d->value, (char **) NULL, 0);
+	if (   (getlong (d->value, &val) == 0)
+	    || (val > INT_MAX)
+	    || (val < INT_MIN)) {
+		fprintf (stderr,
+		         _("configuration error - cannot parse %s value: '%s'"),
+		         item, d->value);
+		return dflt;
+	}
+
+	return (int) val;
 }


@@ -209,14 +239,27 @@ int getdef_num (const char *item, int dflt)
 unsigned int getdef_unum (const char *item, unsigned int dflt)
 {
 	struct itemdef *d;
+	long val;

-	if (!def_loaded)
+	if (!def_loaded) {
 		def_load ();
+	}

-	if ((d = def_find (item)) == NULL || d->value == NULL)
+	d = def_find (item);
+	if ((NULL == d) || (NULL == d->value)) {
 		return dflt;
+	}

-	return (unsigned int) strtoul (d->value, (char **) NULL, 0);
+	if (   (getlong (d->value, &val) == 0)
+	    || (val < 0)
+	    || (val > INT_MAX)) {
+		fprintf (stderr,
+		         _("configuration error - cannot parse %s value: '%s'"),
+		         item, d->value);
+		return dflt;
+	}
+
+	return (unsigned int) val;
 }


@@ -231,16 +274,59 @@ unsigned int getdef_unum (const char *item, unsigned int dflt)
 long getdef_long (const char *item, long dflt)
 {
 	struct itemdef *d;
+	long val;

-	if (!def_loaded)
+	if (!def_loaded) {
 		def_load ();
+	}

-	if ((d = def_find (item)) == NULL || d->value == NULL)
+	d = def_find (item);
+	if ((NULL == d) || (NULL == d->value)) {
 		return dflt;
+	}

-	return strtol (d->value, (char **) NULL, 0);
+	if (getlong (d->value, &val) == 0) {
+		fprintf (stderr,
+		         _("configuration error - cannot parse %s value: '%s'"),
+		         item, d->value);
+		return dflt;
+	}
+
+	return val;
 }

+/*
+ * getdef_ulong - get unsigned long numerical value from table of definitions
+ *
+ * Returns numeric value of specified item, else the "dflt" value if
+ * the item is not defined.  Octal (leading "0") and hex (leading "0x")
+ * values are handled.
+ */
+
+unsigned long getdef_ulong (const char *item, unsigned long dflt)
+{
+	struct itemdef *d;
+	unsigned long val;
+
+	if (!def_loaded) {
+		def_load ();
+	}
+
+	d = def_find (item);
+	if ((NULL == d) || (NULL == d->value)) {
+		return dflt;
+	}
+
+	if (getulong (d->value, &val) == 0) {
+		/* FIXME: we should have a getulong */
+		fprintf (stderr,
+		         _("configuration error - cannot parse %s value: '%s'"),
+		         item, d->value);
+		return dflt;
+	}
+
+	return val;
+}

 /*
 * putdef_str - override the value read from /etc/login.defs
@@ -252,28 +338,33 @@ int putdef_str (const char *name, const char *value)
 	struct itemdef *d;
 	char *cp;

-	if (!def_loaded)
+	if (!def_loaded) {
 		def_load ();
+	}

 	/*
 	 * Locate the slot to save the value.  If this parameter
 	 * is unknown then "def_find" will print an err message.
 	 */
-	if ((d = def_find (name)) == NULL)
+	d = def_find (name);
+	if (NULL == d) {
 		return -1;
+	}

 	/*
 	 * Save off the value.
 	 */
-	if ((cp = strdup (value)) == NULL) {
-		fputs (_("Could not allocate space for config info.\n"),
-		       stderr);
+	cp = strdup (value);
+	if (NULL == cp) {
+		(void) fputs (_("Could not allocate space for config info.\n"),
+		              stderr);
 		SYSLOG ((LOG_ERR, "could not allocate space for config info"));
 		return -1;
 	}

-	if (d->value)
+	if (NULL != d->value) {
 		free (d->value);
+	}

 	d->value = cp;
 	return 0;
@@ -287,9 +378,8 @@ int putdef_str (const char *name, const char *value)
 * specified configuration option.
 */

-static struct itemdef *def_find (const char *name)
+static /*@observer@*/ /*@null@*/struct itemdef *def_find (const char *name)
 {
-	int n;
 	struct itemdef *ptr;


@@ -297,9 +387,10 @@ static struct itemdef *def_find (const char *name)
 	 * Search into the table.
 	 */

-	for (ptr = def_table; ptr->name; ptr++) {
-		if (!(n = strcmp (ptr->name, name)))
+	for (ptr = def_table; NULL != ptr->name; ptr++) {
+		if (strcmp (ptr->name, name) == 0) {
 			return ptr;
+		}
 	}

 	/*
@@ -307,9 +398,8 @@ static struct itemdef *def_find (const char *name)
 	 */

 	fprintf (stderr,
-		 _
-		 ("configuration error - unknown item '%s' (notify administrator)\n"),
-		 name);
+	         _("configuration error - unknown item '%s' (notify administrator)\n"),
+	         name);
 	SYSLOG ((LOG_CRIT, "unknown configuration item `%s'", name));
 	return (struct itemdef *) NULL;
 }
@@ -329,31 +419,35 @@ static void def_load (void)
 	/*
 	 * Open the configuration definitions file.
 	 */
-	if ((fp = fopen (def_fname, "r")) == NULL) {
-		SYSLOG ((LOG_CRIT, "cannot open login definitions %s [%m]",
-			 def_fname));
-		exit (1);
+	fp = fopen (def_fname, "r");
+	if (NULL == fp) {
+		int err = errno;
+		SYSLOG ((LOG_CRIT, "cannot open login definitions %s [%s]",
+		         def_fname, strerror (err)));
+		exit (EXIT_FAILURE);
 	}

 	/*
 	 * Set the initialized flag.
 	 * (do it early to prevent recursion in putdef_str())
 	 */
-	++def_loaded;
+	def_loaded = true;

 	/*
 	 * Go through all of the lines in the file.
 	 */
-	while (fgets (buf, sizeof (buf), fp) != NULL) {
+	while (fgets (buf, (int) sizeof (buf), fp) != NULL) {

 		/*
 		 * Trim trailing whitespace.
 		 */
-		for (i = strlen (buf) - 1; i >= 0; --i) {
-			if (!isspace (buf[i]))
+		for (i = (int) strlen (buf) - 1; i >= 0; --i) {
+			if (!isspace (buf[i])) {
 				break;
+			}
 		}
-		buf[++i] = '\0';
+		i++;
+		buf[i] = '\0';

 		/*
 		 * Break the line into two fields.
@@ -372,14 +466,19 @@ static void def_load (void)

 		/*
 		 * Store the value in def_table.
+		 *
+		 * Ignore failures to load the login.defs file.
+		 * The error was already reported to the user and to
+		 * syslog. The tools will just use their default values.
 		 */
-		putdef_str (name, value);
+		(void)putdef_str (name, value);
 	}

-	if (ferror (fp)) {
-		SYSLOG ((LOG_CRIT, "cannot read login definitions %s [%m]",
-			 def_fname));
-		exit (1);
+	if (ferror (fp) != 0) {
+		int err = errno;
+		SYSLOG ((LOG_CRIT, "cannot read login definitions %s [%s]",
+		         def_fname, strerror (err)));
+		exit (EXIT_FAILURE);
 	}

 	(void) fclose (fp);
@@ -396,18 +495,22 @@ int main (int argc, char **argv)
 	def_load ();

 	for (i = 0; i < NUMDEFS; ++i) {
-		if ((d = def_find (def_table[i].name)) == NULL)
+		d = def_find (def_table[i].name);
+		if (NULL == d) {
 			printf ("error - lookup '%s' failed\n",
-				def_table[i].name);
-		else
+			        def_table[i].name);
+		} else {
 			printf ("%4d %-24s %s\n", i + 1, d->name, d->value);
+		}
 	}
 	for (i = 1; i < argc; i++) {
-		if ((cp = getdef_str (argv[1])) != NULL)
+		cp = getdef_str (argv[1]);
+		if (NULL != cp) {
 			printf ("%s `%s'\n", argv[1], cp);
-		else
+		} else {
 			printf ("%s not found\n", argv[1]);
+		}
 	}
-	exit (0);
+	exit (EXIT_SUCCESS);
 }
 #endif
--- a/lib/getdef.h
+++ b/lib/getdef.h
@@ -2,6 +2,7 @@
 * Copyright (c) 1991 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2002 - 2006, Tomasz Kłoczko
+ * Copyright (c) 2008       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -32,11 +33,12 @@
 #define _GETDEF_H

 /* getdef.c */
-extern int getdef_bool (const char *);
+extern bool getdef_bool (const char *);
 extern long getdef_long (const char *, long);
 extern int getdef_num (const char *, int);
+extern unsigned long getdef_ulong (const char *, unsigned long);
 extern unsigned int getdef_unum (const char *, unsigned int);
-extern char *getdef_str (const char *);
+extern /*@observer@*/ /*@null@*/const char *getdef_str (const char *);
 extern int putdef_str (const char *, const char *);

 /* default UMASK value if not specified in /etc/login.defs */
--- a/libmisc/getlong.c
+++ b/libmisc/getlong.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007       , Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -31,17 +31,27 @@

 #ident "$Id$"

+#include <stdlib.h>
+#include <errno.h>
 #include "prototypes.h"
-#include "defines.h"

-int getlong(const char *numstr, long int *result)
+/*
+ * getlong - extract a long integer provided by the numstr string in *result
+ *
+ * It supports decimal, hexadecimal or octal representations.
+ *
+ * Returns 0 on failure, 1 on success.
+ */
+int getlong (const char *numstr, /*@out@*/long int *result)
 {
 	long val;
 	char *endptr;

-	val = strtol (numstr, &endptr, 10);
-	if (*endptr || errno == ERANGE)
+	errno = 0;
+	val = strtol (numstr, &endptr, 0);
+	if (('\0' == *numstr) || ('\0' != *endptr) || (ERANGE == errno)) {
 		return 0;
+	}

 	*result = val;
 	return 1;
--- a/lib/getulong.c
+++ b/lib/getulong.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2007 - 2009, Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id: getlong.c 2763 2009-04-23 09:57:03Z nekral-guest $"
+
+#include <stdlib.h>
+#include <errno.h>
+#include "prototypes.h"
+
+/*
+ * getulong - extract an unsigned long integer provided by the numstr string in *result
+ *
+ * It supports decimal, hexadecimal or octal representations.
+ *
+ * Returns 0 on failure, 1 on success.
+ */
+int getulong (const char *numstr, /*@out@*/unsigned long int *result)
+{
+	long long int val;
+	char *endptr;
+
+	errno = 0;
+	val = strtoll (numstr, &endptr, 0);
+	if (    ('\0' == *numstr)
+	     || ('\0' != *endptr)
+	     || (ERANGE == errno)
+	     /*@+ignoresigns@*/
+	     || (val != (unsigned long int)val)
+	     /*@=ignoresigns@*/
+	   ) {
+		return 0;
+	}
+
+	*result = (unsigned long int)val;
+	return 1;
+}
+
--- a/lib/groupio.c
+++ b/lib/groupio.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -35,6 +35,7 @@

 #ident "$Id$"

+#include <assert.h>
 #include <stdio.h>

 #include "prototypes.h"
@@ -43,29 +44,24 @@
 #include "getdef.h"
 #include "groupio.h"

-static struct commonio_entry *merge_group_entries (struct commonio_entry *gr1,
-                                                   struct commonio_entry *gr2);
+static /*@null@*/struct commonio_entry *merge_group_entries (
+	/*@null@*/ /*@returned@*/struct commonio_entry *gr1,
+	/*@null@*/struct commonio_entry *gr2);
 static int split_groups (unsigned int max_members);
 static int group_open_hook (void);

-static void *group_dup (const void *ent)
+static /*@null@*/ /*@only@*/void *group_dup (const void *ent)
 {
 	const struct group *gr = ent;

 	return __gr_dup (gr);
 }

-static void group_free (void *ent)
+static void group_free (/*@out@*/ /*@only@*/void *ent)
 {
 	struct group *gr = ent;

-	free (gr->gr_name);
-	free (gr->gr_passwd);
-	while (*(gr->gr_mem)) {
-		free (*(gr->gr_mem));
-		gr->gr_mem++;
-	}
-	free (gr);
+	gr_free (gr);
 }

 static const char *group_getname (const void *ent)
@@ -84,6 +80,23 @@ static int group_put (const void *ent, FILE * file)
 {
 	const struct group *gr = ent;

+	if (   (NULL == gr)
+	    || (valid_field (gr->gr_name, ":\n") == -1)
+	    || (valid_field (gr->gr_passwd, ":\n") == -1)
+	    || (gr->gr_gid == (gid_t)-1)) {
+		return -1;
+	}
+
+	/* FIXME: fail also if gr->gr_mem == NULL ?*/
+	if (NULL != gr->gr_mem) {
+		size_t i;
+		for (i = 0; NULL != gr->gr_mem[i]; i++) {
+			if (valid_field (gr->gr_mem[i], ",:\n") == -1) {
+				return -1;
+			}
+		}
+	}
+
 	return (putgrent (gr, file) == -1) ? -1 : 0;
 }

@@ -91,8 +104,9 @@ static int group_close_hook (void)
 {
 	unsigned int max_members = getdef_unum("MAX_MEMBERS_PER_GROUP", 0);

-	if (0 == max_members)
+	if (0 == max_members) {
 		return 1;
+	}

 	return split_groups (max_members);
 }
@@ -109,7 +123,7 @@ static struct commonio_ops group_ops = {
 	group_close_hook
 };

-static struct commonio_db group_db = {
+static /*@owned@*/struct commonio_db group_db = {
 	GROUP_FILE,		/* filename */
 	&group_ops,		/* ops */
 	NULL,			/* fp */
@@ -119,17 +133,22 @@ static struct commonio_db group_db = {
 	NULL,			/* head */
 	NULL,			/* tail */
 	NULL,			/* cursor */
-	0,			/* changed */
-	0,			/* isopen */
-	0,			/* locked */
-	0			/* readonly */
+	false,			/* changed */
+	false,			/* isopen */
+	false,			/* locked */
+	false			/* readonly */
 };

-int gr_name (const char *filename)
+int gr_setdbname (const char *filename)
 {
 	return commonio_setname (&group_db, filename);
 }

+/*@observer@*/const char *gr_dbname (void)
+{
+	return group_db.filename;
+}
+
 int gr_lock (void)
 {
 	return commonio_lock (&group_db);
@@ -140,12 +159,12 @@ int gr_open (int mode)
 	return commonio_open (&group_db, mode);
 }

-const struct group *gr_locate (const char *name)
+/*@observer@*/ /*@null@*/const struct group *gr_locate (const char *name)
 {
 	return commonio_locate (&group_db, name);
 }

-const struct group *gr_locate_gid (gid_t gid)
+/*@observer@*/ /*@null@*/const struct group *gr_locate_gid (gid_t gid)
 {
 	const struct group *grp;

@@ -172,7 +191,7 @@ int gr_rewind (void)
 	return commonio_rewind (&group_db);
 }

-const struct group *gr_next (void)
+/*@observer@*/ /*@null@*/const struct group *gr_next (void)
 {
 	return commonio_next (&group_db);
 }
@@ -189,15 +208,15 @@ int gr_unlock (void)

 void __gr_set_changed (void)
 {
-	group_db.changed = 1;
+	group_db.changed = true;
 }

-struct commonio_entry *__gr_get_head (void)
+/*@dependent@*/ /*@null@*/struct commonio_entry *__gr_get_head (void)
 {
 	return group_db.head;
 }

-struct commonio_db *__gr_get_db (void)
+/*@observer@*/const struct commonio_db *__gr_get_db (void)
 {
 	return &group_db;
 }
@@ -211,20 +230,23 @@ static int gr_cmp (const void *p1, const void *p2)
 {
 	gid_t u1, u2;

-	if ((*(struct commonio_entry **) p1)->eptr == NULL)
+	if ((*(struct commonio_entry **) p1)->eptr == NULL) {
 		return 1;
-	if ((*(struct commonio_entry **) p2)->eptr == NULL)
+	}
+	if ((*(struct commonio_entry **) p2)->eptr == NULL) {
 		return -1;
+	}

 	u1 = ((struct group *) (*(struct commonio_entry **) p1)->eptr)->gr_gid;
 	u2 = ((struct group *) (*(struct commonio_entry **) p2)->eptr)->gr_gid;

-	if (u1 < u2)
+	if (u1 < u2) {
 		return -1;
-	else if (u1 > u2)
+	} else if (u1 > u2) {
 		return 1;
-	else
+	} else {
 		return 0;
+	}
 }

 /* Sort entries by GID */
@@ -238,11 +260,12 @@ static int group_open_hook (void)
 	unsigned int max_members = getdef_unum("MAX_MEMBERS_PER_GROUP", 0);
 	struct commonio_entry *gr1, *gr2;

-	if (0 == max_members)
+	if (0 == max_members) {
 		return 1;
+	}

-	for (gr1 = group_db.head; gr1; gr1 = gr1->next) {
-		for (gr2 = gr1->next; gr2; gr2 = gr2->next) {
+	for (gr1 = group_db.head; NULL != gr1; gr1 = gr1->next) {
+		for (gr2 = gr1->next; NULL != gr2; gr2 = gr2->next) {
 			struct group *g1 = (struct group *)gr1->eptr;
 			struct group *g2 = (struct group *)gr2->eptr;
 			if (NULL != g1 &&
@@ -257,11 +280,15 @@ static int group_open_hook (void)
 				if (NULL == gr1)
 					return 0;
 				/* Unlink gr2 */
-				if (NULL != gr2->next)
+				if (NULL != gr2->next) {
 					gr2->next->prev = gr2->prev;
+				}
+				/* gr2 does not start with head */
+				assert (NULL != gr2->prev);
 				gr2->prev->next = gr2->next;
 			}
 		}
+		assert (NULL != gr1);
 	}

 	return 1;
@@ -279,15 +306,16 @@ static int group_open_hook (void)
 * the modified first entry on success, or NULL on failure (with errno
 * set).
 */
-static struct commonio_entry *merge_group_entries (struct commonio_entry *gr1,
-                                                   struct commonio_entry *gr2)
+static /*@null@*/struct commonio_entry *merge_group_entries (
+	/*@null@*/ /*@returned@*/struct commonio_entry *gr1,
+	/*@null@*/struct commonio_entry *gr2)
 {
 	struct group *gptr1;
 	struct group *gptr2;
 	char **new_members;
-	int members = 0;
+	size_t members = 0;
 	char *new_line;
-	int new_line_len, i;
+	size_t new_line_len, i;
 	if (NULL == gr2 || NULL == gr1) {
 		errno = EINVAL;
 		return NULL;
@@ -302,7 +330,7 @@ static struct commonio_entry *merge_group_entries (struct commonio_entry *gr1,

 	/* Concatenate the 2 lines */
 	new_line_len = strlen (gr1->line) + strlen (gr2->line) +1;
-	new_line = (char *)malloc ((new_line_len + 1) * sizeof(char*));
+	new_line = (char *)malloc (new_line_len + 1);
 	if (NULL == new_line) {
 		errno = ENOMEM;
 		return NULL;
@@ -316,30 +344,38 @@ static struct commonio_entry *merge_group_entries (struct commonio_entry *gr1,
 	for (i=0; NULL != gptr2->gr_mem[i]; i++) {
 		char **pmember = gptr1->gr_mem;
 		while (NULL != *pmember) {
-			if (0 == strcmp(*pmember, gptr2->gr_mem[i]))
+			if (0 == strcmp(*pmember, gptr2->gr_mem[i])) {
 				break;
+			}
 			pmember++;
 		}
-		if (NULL == *pmember)
+		if (NULL == *pmember) {
 			members++;
+		}
 	}
-	new_members = (char **)malloc ( (members+1) * sizeof(char*) );
+	new_members = (char **)calloc ( (members+1), sizeof(char*) );
 	if (NULL == new_members) {
+		free (new_line);
 		errno = ENOMEM;
 		return NULL;
 	}
-	for (i=0; NULL != gptr1->gr_mem[i]; i++)
+	for (i=0; NULL != gptr1->gr_mem[i]; i++) {
 		new_members[i] = gptr1->gr_mem[i];
+	}
+	/* NULL termination enforced by above calloc */
+
 	members = i;
 	for (i=0; NULL != gptr2->gr_mem[i]; i++) {
 		char **pmember = new_members;
 		while (NULL != *pmember) {
-			if (0 == strcmp(*pmember, gptr2->gr_mem[i]))
+			if (0 == strcmp(*pmember, gptr2->gr_mem[i])) {
 				break;
+			}
 			pmember++;
 		}
 		if (NULL == *pmember) {
-			new_members[members++] = gptr2->gr_mem[i];
+			new_members[members] = gptr2->gr_mem[i];
+			members++;
 			new_members[members] = NULL;
 		}
 	}
@@ -360,20 +396,24 @@ static int split_groups (unsigned int max_members)
 {
 	struct commonio_entry *gr;

-	for (gr = group_db.head; gr; gr = gr->next) {
+	for (gr = group_db.head; NULL != gr; gr = gr->next) {
 		struct group *gptr = (struct group *)gr->eptr;
 		struct commonio_entry *new;
 		struct group *new_gptr;
 		unsigned int members = 0;
+		unsigned int i;

 		/* Check if this group must be split */
-		if (!gr->changed)
+		if (!gr->changed) {
 			continue;
-		if (NULL == gptr)
+		}
+		if (NULL == gptr) {
 			continue;
+		}
 		for (members = 0; NULL != gptr->gr_mem[members]; members++);
-		if (members <= max_members)
+		if (members <= max_members) {
 			continue;
+		}

 		new = (struct commonio_entry *) malloc (sizeof *new);
 		if (NULL == new) {
@@ -382,17 +422,32 @@ static int split_groups (unsigned int max_members)
 		}
 		new->eptr = group_dup(gr->eptr);
 		if (NULL == new->eptr) {
+			free (new);
 			errno = ENOMEM;
 			return 0;
 		}
 		new_gptr = (struct group *)new->eptr;
 		new->line = NULL;
-		new->changed = 1;
+		new->changed = true;

 		/* Enforce the maximum number of members on gptr */
-		gptr->gr_mem[max_members] = NULL;
+		for (i = max_members; NULL != gptr->gr_mem[i]; i++) {
+			free (gptr->gr_mem[i]);
+			gptr->gr_mem[i] = NULL;
+		}
+		/* Shift all the members */
 		/* The number of members in new_gptr will be check later */
-		new_gptr->gr_mem = &new_gptr->gr_mem[max_members];
+		for (i = 0; NULL != new_gptr->gr_mem[i + max_members]; i++) {
+			if (NULL != new_gptr->gr_mem[i]) {
+				free (new_gptr->gr_mem[i]);
+			}
+			new_gptr->gr_mem[i] = new_gptr->gr_mem[i + max_members];
+			new_gptr->gr_mem[i + max_members] = NULL;
+		}
+		for (; NULL != new_gptr->gr_mem[i]; i++) {
+			free (new_gptr->gr_mem[i]);
+			new_gptr->gr_mem[i] = NULL;
+		}

 		/* insert the new entry in the list */
 		new->prev = gr;
--- a/lib/groupio.h
+++ b/lib/groupio.h
@@ -31,17 +31,25 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

+/* $Id$ */
+#ifndef _GROUPIO_H
+#define _GROUPIO_H
+
+#include <sys/types.h>
 #include <grp.h>
+
 extern int gr_close (void);
-extern const struct group *gr_locate (const char *);
-extern const struct group *gr_locate_gid (gid_t gid);
+extern /*@observer@*/ /*@null@*/const struct group *gr_locate (const char *name);
+extern /*@observer@*/ /*@null@*/const struct group *gr_locate_gid (gid_t gid);
 extern int gr_lock (void);
-extern int gr_name (const char *);
-extern const struct group *gr_next (void);
-extern int gr_open (int);
-extern int gr_remove (const char *);
+extern int gr_setdbname (const char *filename);
+extern /*@observer@*/const char *gr_dbname (void);
+extern /*@observer@*/ /*@null@*/const struct group *gr_next (void);
+extern int gr_open (int mode);
+extern int gr_remove (const char *name);
 extern int gr_rewind (void);
 extern int gr_unlock (void);
-extern int gr_update (const struct group *);
+extern int gr_update (const struct group *gr);
 extern int gr_sort (void);

+#endif
--- a/lib/groupmem.c
+++ b/lib/groupmem.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2007       , Nicolas François
+ * Copyright (c) 2007 - 2013, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -39,29 +39,77 @@
 #include "defines.h"
 #include "groupio.h"

-struct group *__gr_dup (const struct group *grent)
+/*@null@*/ /*@only@*/struct group *__gr_dup (const struct group *grent)
 {
 	struct group *gr;
 	int i;

-	if (!(gr = (struct group *) malloc (sizeof *gr)))
+	gr = (struct group *) malloc (sizeof *gr);
+	if (NULL == gr) {
 		return NULL;
-	*gr = *grent;
-	if (!(gr->gr_name = strdup (grent->gr_name)))
+	}
+	/* The libc might define other fields. They won't be copied. */
+	memset (gr, 0, sizeof *gr);
+	gr->gr_gid = grent->gr_gid;
+	/*@-mustfreeonly@*/
+	gr->gr_name = strdup (grent->gr_name);
+	/*@=mustfreeonly@*/
+	if (NULL == gr->gr_name) {
+		free(gr);
 		return NULL;
-	if (!(gr->gr_passwd = strdup (grent->gr_passwd)))
+	}
+	/*@-mustfreeonly@*/
+	gr->gr_passwd = strdup (grent->gr_passwd);
+	/*@=mustfreeonly@*/
+	if (NULL == gr->gr_passwd) {
+		free(gr->gr_name);
+		free(gr);
 		return NULL;
+	}

 	for (i = 0; grent->gr_mem[i]; i++);
+
+	/*@-mustfreeonly@*/
 	gr->gr_mem = (char **) malloc ((i + 1) * sizeof (char *));
-	if (!gr->gr_mem)
+	/*@=mustfreeonly@*/
+	if (NULL == gr->gr_mem) {
+		free(gr->gr_passwd);
+		free(gr->gr_name);
+		free(gr);
 		return NULL;
+	}
 	for (i = 0; grent->gr_mem[i]; i++) {
 		gr->gr_mem[i] = strdup (grent->gr_mem[i]);
-		if (!gr->gr_mem[i])
+		if (NULL == gr->gr_mem[i]) {
+			int j;
+			for (j=0; j<i; j++)
+				free(gr->gr_mem[j]);
+			free(gr->gr_mem);
+			free(gr->gr_passwd);
+			free(gr->gr_name);
+			free(gr);
 			return NULL;
+		}
 	}
 	gr->gr_mem[i] = NULL;
+
 	return gr;
 }

+void gr_free (/*@out@*/ /*@only@*/struct group *grent)
+{
+	free (grent->gr_name);
+	if (NULL != grent->gr_passwd) {
+		memzero (grent->gr_passwd, strlen (grent->gr_passwd));
+		free (grent->gr_passwd);
+	}
+	if (NULL != grent->gr_mem) {
+		size_t i;
+		for (i = 0; NULL != grent->gr_mem[i]; i++) {
+			free (grent->gr_mem[i]);
+		}
+		free (grent->gr_mem);
+	}
+	free (grent);
+}
+
--- a/lib/gshadow.c
+++ b/lib/gshadow.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1990 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2008       , Nicolas François
+ * Copyright (c) 2008 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -40,21 +40,20 @@
 #include <stdio.h>
 #include "prototypes.h"
 #include "defines.h"
-static FILE *shadow;
-static char sgrbuf[BUFSIZ * 4];
-static char **members = NULL;
+static /*@null@*/FILE *shadow;
+static /*@null@*//*@only@*/char **members = NULL;
 static size_t nmembers = 0;
-static char **admins = NULL;
+static /*@null@*//*@only@*/char **admins = NULL;
 static size_t nadmins = 0;
 static struct sgrp sgroup;

 #define	FIELDS	4

 #ifdef	USE_NIS
-static int nis_used;
-static int nis_ignore;
+static bool nis_used;
+static bool nis_ignore;
 static enum { native, start, middle, native2 } nis_state;
-static int nis_bound;
+static bool nis_bound;
 static char *nis_domain;
 static char *nis_key;
 static int nis_keylen;
@@ -65,19 +64,6 @@ static int nis_vallen;
 #endif

 #ifdef	USE_NIS
-
-/*
- * __setsgNIS - turn on or off NIS searches
- */
-
-void __setsgNIS (int flag)
-{
-	nis_ignore = !flag;
-
-	if (nis_ignore)
-		nis_used = 0;
-}
-
 /*
 * bind_nis - bind to NIS server
 */
@@ -87,29 +73,35 @@ static int bind_nis (void)
 	if (yp_get_default_domain (&nis_domain))
 		return -1;

-	nis_bound = 1;
+	nis_bound = true;
 	return 0;
 }
 #endif

-static char **build_list (char *s, char **list[], size_t * nlist)
+static /*@null@*/char **build_list (char *s, char **list[], size_t * nlist)
 {
 	char **ptr = *list;
 	size_t nelem = *nlist, size;

 	while (s != NULL && *s != '\0') {
 		size = (nelem + 1) * sizeof (ptr);
-		if ((ptr = realloc (*list, size)) != NULL) {
-			ptr[nelem++] = s;
+		ptr = realloc (*list, size);
+		if (NULL != ptr) {
+			ptr[nelem] = s;
+			nelem++;
 			*list = ptr;
 			*nlist = nelem;
-			if ((s = strchr (s, ',')))
-				*s++ = '\0';
+			s = strchr (s, ',');
+			if (NULL != s) {
+				*s = '\0';
+				s++;
+			}
 		}
 	}
 	size = (nelem + 1) * sizeof (ptr);
-	if ((ptr = realloc (*list, size)) != NULL) {
-		ptr[nelem] = '\0';
+	ptr = realloc (*list, size);
+	if (NULL != ptr) {
+		ptr[nelem] = NULL;
 		*list = ptr;
 	}
 	return ptr;
@@ -120,41 +112,60 @@ void setsgent (void)
 #ifdef	USE_NIS
 	nis_state = native;
 #endif
-	if (shadow)
+	if (NULL != shadow) {
 		rewind (shadow);
-	else
+	} else {
 		shadow = fopen (SGROUP_FILE, "r");
+	}
 }

 void endsgent (void)
 {
-	if (shadow)
+	if (NULL != shadow) {
 		(void) fclose (shadow);
+	}

 	shadow = (FILE *) 0;
 }

-struct sgrp *sgetsgent (const char *string)
+/*@observer@*//*@null@*/struct sgrp *sgetsgent (const char *string)
 {
+	static char *sgrbuf = NULL;
+	static size_t sgrbuflen = 0;
+
 	char *fields[FIELDS];
 	char *cp;
 	int i;
+	size_t len = strlen (string) + 1;

-	strncpy (sgrbuf, string, (int) sizeof sgrbuf - 1);
-	sgrbuf[sizeof sgrbuf - 1] = '\0';
+	if (len > sgrbuflen) {
+		char *buf = (char *) realloc (sgrbuf, sizeof (char) * len);
+		if (NULL == buf) {
+			return NULL;
+		}
+		sgrbuf = buf;
+		sgrbuflen = len;
+	}

-	if ((cp = strrchr (sgrbuf, '\n')))
+	strncpy (sgrbuf, string, len);
+	sgrbuf[len-1] = '\0';
+
+	cp = strrchr (sgrbuf, '\n');
+	if (NULL != cp) {
 		*cp = '\0';
+	}

 	/*
 	 * There should be exactly 4 colon separated fields.  Find
 	 * all 4 of them and save the starting addresses in fields[].
 	 */

-	for (cp = sgrbuf, i = 0; i < FIELDS && cp; i++) {
+	for (cp = sgrbuf, i = 0; (i < FIELDS) && (NULL != cp); i++) {
 		fields[i] = cp;
-		if ((cp = strchr (cp, ':')))
+		cp = strchr (cp, ':');
+		if (NULL != cp) {
 			*cp++ = '\0';
+		}
 	}

 	/*
@@ -162,24 +173,26 @@ struct sgrp *sgetsgent (const char *string)
 	 * the line is invalid.
 	 */

-	if (cp || i != FIELDS)
+	if ((NULL != cp) || (i != FIELDS)) {
 #ifdef	USE_NIS
-		if (!IS_NISCHAR (fields[0][0]))
+		if (!IS_NISCHAR (fields[0][0])) {
 			return 0;
-		else
-			nis_used = 1;
+		} else {
+			nis_used = true;
+		}
 #else
 		return 0;
 #endif
+	}

 	sgroup.sg_name = fields[0];
 	sgroup.sg_passwd = fields[1];
-	if (nadmins) {
+	if (0 != nadmins) {
 		nadmins = 0;
 		free (admins);
 		admins = NULL;
 	}
-	if (nmembers) {
+	if (0 != nmembers) {
 		nmembers = 0;
 		free (members);
 		members = NULL;
@@ -197,44 +210,76 @@ struct sgrp *sgetsgent (const char *string)
 * converts it to a (struct sgrp).  NULL is returned on EOF.
 */

-struct sgrp *fgetsgent (FILE * fp)
+/*@observer@*//*@null@*/struct sgrp *fgetsgent (/*@null@*/FILE * fp)
 {
-	char buf[sizeof sgrbuf];
+	static size_t buflen = 0;
+	static char *buf = NULL;
+
 	char *cp;

-	if (!fp)
-		return (0);
+	if (0 == buflen) {
+		buf = (char *) malloc (BUFSIZ);
+		if (NULL == buf) {
+			return NULL;
+		}
+		buflen = BUFSIZ;
+	}
+
+	if (NULL == fp) {
+		return NULL;
+	}

 #ifdef	USE_NIS
-	while (fgetsx (buf, sizeof buf, fp) != (char *) 0)
+	while (fgetsx (buf, (int) buflen, fp) == buf)
 #else
-	if (fgetsx (buf, sizeof buf, fp) != (char *) 0)
+	if (fgetsx (buf, (int) buflen, fp) == buf)
 #endif
 	{
-		if ((cp = strchr (buf, '\n')))
+		while (   ((cp = strrchr (buf, '\n')) == NULL)
+		       && (feof (fp) == 0)) {
+			size_t len;
+
+			cp = (char *) realloc (buf, buflen*2);
+			if (NULL == cp) {
+				return NULL;
+			}
+			buf = cp;
+			buflen *= 2;
+
+			len = strlen (buf);
+			if (fgetsx (&buf[len],
+			            (int) (buflen - len),
+			            fp) != &buf[len]) {
+				return NULL;
+			}
+		}
+		cp = strrchr (buf, '\n');
+		if (NULL != cp) {
 			*cp = '\0';
+		}
 #ifdef	USE_NIS
-		if (nis_ignore && IS_NISCHAR (buf[0]))
+		if (nis_ignore && IS_NISCHAR (buf[0])) {
 			continue;
+		}
 #endif
 		return (sgetsgent (buf));
 	}
-	return 0;
+	return NULL;
 }

 /*
 * getsgent - get a single shadow group entry
 */

-struct sgrp *getsgent (void)
+/*@observer@*//*@null@*/struct sgrp *getsgent (void)
 {
 #ifdef	USE_NIS
-	int nis_1_group = 0;
+	bool nis_1_group = false;
 	struct sgrp *val;
-	char buf[BUFSIZ];
 #endif
-	if (!shadow)
+	if (NULL == shadow) {
 		setsgent ();
+	}

 #ifdef	USE_NIS
      again:
@@ -249,8 +294,10 @@ struct sgrp *getsgent (void)
 		 * NULL right away if there is none.
 		 */

-		if (!(val = fgetsgent (shadow)))
+		val = fgetsgent (shadow);
+		if (NULL == val) {
 			return 0;
+		}

 		/*
 		 * If this entry began with a NIS escape character, we have
@@ -259,10 +306,11 @@ struct sgrp *getsgent (void)
 		 */

 		if (IS_NISCHAR (val->sg_name[0])) {
-			if (val->sg_name[1])
-				nis_1_group = 1;
-			else
+			if ('\0' != val->sg_name[1]) {
+				nis_1_group = true;
+			} else {
 				nis_state = start;
+			}
 		}

 		/*
@@ -270,16 +318,18 @@ struct sgrp *getsgent (void)
 		 * use a NIS map, it must be a regular local group.
 		 */

-		if (nis_1_group == 0 && nis_state != start)
+		if (!nis_1_group && (nis_state != start)) {
 			return val;
+		}

 		/*
 		 * If this is an escape to use an NIS map, switch over to
 		 * that bunch of code.
 		 */

-		if (nis_state == start)
+		if (nis_state == start) {
 			goto again;
+		}

 		/*
 		 * NEEDSWORK.  Here we substitute pieces-parts of this entry.
@@ -287,7 +337,7 @@ struct sgrp *getsgent (void)

 		return 0;
 	} else {
-		if (nis_bound == 0) {
+		if (!nis_bound) {
 			if (bind_nis ()) {
 				nis_state = native2;
 				goto again;
@@ -319,12 +369,11 @@ struct sgrp *getsgent (void)
 * getsgnam - get a shadow group entry by name
 */

-struct sgrp *getsgnam (const char *name)
+/*@observer@*//*@null@*/struct sgrp *getsgnam (const char *name)
 {
 	struct sgrp *sgrp;

 #ifdef	USE_NIS
-	char buf[BUFSIZ];
 	static char save_name[16];
 	int nis_disabled = 0;
 #endif
@@ -339,8 +388,9 @@ struct sgrp *getsgnam (const char *name)
 		 * Search the gshadow.byname map for this group.
 		 */

-		if (!nis_bound)
+		if (!nis_bound) {
 			bind_nis ();
+		}

 		if (nis_bound) {
 			char *cp;
@@ -348,11 +398,14 @@ struct sgrp *getsgnam (const char *name)
 			if (yp_match (nis_domain, "gshadow.byname", name,
 				      strlen (name), &nis_val,
 				      &nis_vallen) == 0) {
-				if (cp = strchr (nis_val, '\n'))
+				cp = strchr (nis_val, '\n');
+				if (NULL != cp) {
 					*cp = '\0';
+				}

 				nis_state = middle;
-				if (sgrp = sgetsgent (nis_val)) {
+				sgrp = sgetsgent (nis_val);
+				if (NULL != sgrp) {
 					strcpy (save_name, sgrp->sg_name);
 					nis_key = save_name;
 					nis_keylen = strlen (save_name);
@@ -365,20 +418,19 @@ struct sgrp *getsgnam (const char *name)
 #endif
 #ifdef	USE_NIS
 	if (nis_used) {
-		nis_ignore++;
-		nis_disabled++;
+		nis_ignore = true;
+		nis_disabled = true;
 	}
 #endif
 	while ((sgrp = getsgent ()) != (struct sgrp *) 0) {
-		if (strcmp (name, sgrp->sg_name) == 0)
+		if (strcmp (name, sgrp->sg_name) == 0) {
 			break;
+		}
 	}
 #ifdef	USE_NIS
-	nis_ignore--;
+	nis_ignore = false;
 #endif
-	if (sgrp)
-		return sgrp;
-	return (0);
+	return sgrp;
 }

 /*
@@ -395,19 +447,23 @@ int putsgent (const struct sgrp *sgrp, FILE * fp)
 	int i;
 	size_t size;

-	if (!fp || !sgrp)
+	if ((NULL == fp) || (NULL == sgrp)) {
 		return -1;
+	}

 	/* calculate the required buffer size */
 	size = strlen (sgrp->sg_name) + strlen (sgrp->sg_passwd) + 10;
-	for (i = 0; sgrp->sg_adm && sgrp->sg_adm[i]; i++)
+	for (i = 0; (NULL != sgrp->sg_adm) && (NULL != sgrp->sg_adm[i]); i++) {
 		size += strlen (sgrp->sg_adm[i]) + 1;
-	for (i = 0; sgrp->sg_mem && sgrp->sg_mem[i]; i++)
+	}
+	for (i = 0; (NULL != sgrp->sg_mem) && (NULL != sgrp->sg_mem[i]); i++) {
 		size += strlen (sgrp->sg_mem[i]) + 1;
+	}

 	buf = malloc (size);
-	if (!buf)
+	if (NULL == buf) {
 		return -1;
+	}
 	cp = buf;

 	/*
@@ -427,27 +483,32 @@ int putsgent (const struct sgrp *sgrp, FILE * fp)
 	 * with a ",".
 	 */

-	for (i = 0; sgrp->sg_adm[i]; i++) {
-		if (i > 0)
+	for (i = 0; NULL != sgrp->sg_adm[i]; i++) {
+		if (i > 0) {
 			*cp++ = ',';
+		}

 		strcpy (cp, sgrp->sg_adm[i]);
 		cp += strlen (cp);
 	}
-	*cp++ = ':';
+	*cp = ':';
+	cp++;

 	/*
 	 * Now do likewise with the group members.
 	 */

-	for (i = 0; sgrp->sg_mem[i]; i++) {
-		if (i > 0)
-			*cp++ = ',';
+	for (i = 0; NULL != sgrp->sg_mem[i]; i++) {
+		if (i > 0) {
+			*cp = ',';
+			cp++;
+		}

 		strcpy (cp, sgrp->sg_mem[i]);
 		cp += strlen (cp);
 	}
-	*cp++ = '\n';
+	*cp = '\n';
+	cp++;
 	*cp = '\0';

 	/*
--- a/lib/gshadow_.h
+++ b/lib/gshadow_.h
@@ -43,7 +43,7 @@
 struct sgrp {
 	char *sg_name;		/* group name */
 	char *sg_passwd;	/* group password */
-	char **sg_adm;		/* group administator list */
+	char **sg_adm;		/* group administrator list */
 	char **sg_mem;		/* group membership list */
 };

@@ -54,18 +54,18 @@ struct sgrp {
 #include <stdio.h>		/* for FILE */

 #if __STDC__
-struct sgrp *getsgent (void);
-struct sgrp *getsgnam (const char *);
-struct sgrp *sgetsgent (const char *);
-struct sgrp *fgetsgent (FILE *);
+/*@observer@*//*@null@*/struct sgrp *getsgent (void);
+/*@observer@*//*@null@*/struct sgrp *getsgnam (const char *);
+/*@observer@*//*@null@*/struct sgrp *sgetsgent (const char *);
+/*@observer@*//*@null@*/struct sgrp *fgetsgent (/*@null@*/FILE *);
 void setsgent (void);
 void endsgent (void);
 int putsgent (const struct sgrp *, FILE *);
 #else
-struct sgrp *getsgent ();
-struct sgrp *getsgnam ();
-struct sgrp *sgetsgent ();
-struct sgrp *fgetsgent ();
+/*@observer@*//*@null@*/struct sgrp *getsgent ();
+/*@observer@*//*@null@*/struct sgrp *getsgnam ();
+/*@observer@*//*@null@*/struct sgrp *sgetsgent ();
+/*@observer@*//*@null@*/struct sgrp *fgetsgent ();
 void setsgent ();
 void endsgent ();
 int putsgent ();
--- a/lib/nscd.c
+++ b/lib/nscd.c
@@ -1,50 +1,57 @@
 /* Author: Peter Vrabec <pvrabec@redhat.com> */

-/* because of TEMP_FAILURE_RETRY */
-#define _GNU_SOURCE
+#include <config.h>
+#ifdef USE_NSCD

-#include <features.h>
 #include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <spawn.h>
-#include <errno.h>
 #include <sys/wait.h>
 #include <sys/types.h>
+#include "exitcodes.h"
+#include "defines.h"
+#include "prototypes.h"
 #include "nscd.h"

+#define MSG_NSCD_FLUSH_CACHE_FAILED "%s: Failed to flush the nscd cache.\n"
+
 /*
 * nscd_flush_cache - flush specified service buffer in nscd cache
 */
 int nscd_flush_cache (const char *service)
 {
-	pid_t pid, termpid;
-	int err, status;
-	char *spawnedArgs[] = {"/usr/sbin/nscd", "nscd", "-i", service, NULL};
-	char *spawnedEnv[] = {NULL};
+	int status, code;
+	const char *cmd = "/usr/sbin/nscd";
+	const char *spawnedArgs[] = {"nscd", "-i", service, NULL};
+	const char *spawnedEnv[] = {NULL};

-	/* spawn process */
-	if( (err=posix_spawn(&pid, spawnedArgs[0], NULL, NULL,
-			     spawnedArgs, spawnedEnv)) !=0 ) 
-	{
-		fprintf(stderr, "posix_spawn() error=%d\n", err);
+	if (run_command (cmd, spawnedArgs, spawnedEnv, &status) != 0) {
+		/* run_command writes its own more detailed message. */
+		(void) fprintf (stderr, _(MSG_NSCD_FLUSH_CACHE_FAILED), Prog);
 		return -1;
 	}

-	/* Wait for the spawned process to exit */	
-	termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
-	if (termpid == -1)
-	{
-		perror("waitpid");
+	code = WEXITSTATUS (status);
+	if (!WIFEXITED (status)) {
+		(void) fprintf (stderr,
+		                _("%s: nscd did not terminate normally (signal %d)\n"),
+		                Prog, WTERMSIG (status));
 		return -1;
-	}
-	else if (termpid != pid)
-	{
-		fprintf(stderr, "waitpid returned %ld != %ld\n",
-			 (long int) termpid, (long int) pid);
+	} else if (code == E_CMD_NOTFOUND) {
+		/* nscd is not installed, or it is installed but uses an
+		   interpreter that is missing.  Probably the former. */
+		return 0;
+	} else if (code == 1) {
+		/* nscd is installed, but it isn't active. */
+		return 0;
+	} else if (code != 0) {
+		(void) fprintf (stderr, _("%s: nscd exited with status %d\n"),
+		                Prog, code);
+		(void) fprintf (stderr, _(MSG_NSCD_FLUSH_CACHE_FAILED), Prog);
 		return -1;
 	}

 	return 0;
 }
+#else				/* USE_NSCD */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* USE_NSCD */

--- a/lib/nscd.h
+++ b/lib/nscd.h
@@ -4,6 +4,10 @@
 /*
 * nscd_flush_cache - flush specified service buffer in nscd cache
 */
+#ifdef	USE_NSCD
 extern int nscd_flush_cache (const char *service);
+#else
+#define nscd_flush_cache(service) (0)
+#endif

 #endif
--- a/lib/pam_defs.h
+++ b/lib/pam_defs.h
@@ -28,24 +28,31 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

+#include <config.h>
 #include <security/pam_appl.h>
-#include <security/pam_misc.h>
+#ifdef HAVE_SECURITY_PAM_MISC_H
+# include <security/pam_misc.h>
+#endif
+#ifdef HAVE_SECURITY_OPENPAM_H
+# include <security/openpam.h>
+#endif
+

 static struct pam_conv conv = {
-	misc_conv,
+	SHADOW_PAM_CONVERSATION,
 	NULL
 };

 /* compatibility with different versions of Linux-PAM */
-#ifndef PAM_ESTABLISH_CRED
+#if !HAVE_DECL_PAM_ESTABLISH_CRED
 #define PAM_ESTABLISH_CRED PAM_CRED_ESTABLISH
 #endif
-#ifndef PAM_DELETE_CRED
+#if !HAVE_DECL_PAM_DELETE_CRED
 #define PAM_DELETE_CRED PAM_CRED_DELETE
 #endif
-#ifndef PAM_NEW_AUTHTOK_REQD
+#if !HAVE_DECL_PAM_NEW_AUTHTOK_REQD
 #define PAM_NEW_AUTHTOK_REQD PAM_AUTHTOKEN_REQD
 #endif
-#ifndef PAM_DATA_SILENT
+#if !HAVE_DECL_PAM_DATA_SILENT
 #define PAM_DATA_SILENT 0
 #endif
--- a/lib/port.c
+++ b/lib/port.c
@@ -57,15 +57,19 @@ static int portcmp (const char *pattern, const char *port)
 {
 	const char *orig = port;

-	while (*pattern && *pattern == *port)
-		pattern++, port++;
+	while (('\0' != *pattern) && (*pattern == *port)) {
+		pattern++;
+		port++;
+	}

-	if (*pattern == 0 && *port == 0)
+	if (('\0' == *pattern) && ('\0' == *port)) {
 		return 0;
-	if (orig[0] == 'S' && orig[1] == 'U' && orig[2] == '\0')
+	}
+	if (('S' == orig[0]) && ('U' == orig[1]) && ('\0' == orig[2])) {
 		return 1;
+	}

-	return *pattern == '*' ? 0 : 1;
+	return (*pattern == '*') ? 0 : 1;
 }

 /*
@@ -77,10 +81,11 @@ static int portcmp (const char *pattern, const char *port)

 static void setportent (void)
 {
-	if (ports)
+	if (NULL != ports) {
 		rewind (ports);
-	else
+	} else {
 		ports = fopen (PORTS, "r");
+	}
 }

 /*
@@ -93,8 +98,9 @@ static void setportent (void)

 static void endportent (void)
 {
-	if (ports)
-		fclose (ports);
+	if (NULL != ports) {
+		(void) fclose (ports);
+	}

 	ports = (FILE *) 0;
 }
@@ -125,10 +131,11 @@ static struct port *getportent (void)
 	 * since we want to search from the beginning each time.
 	 */

-	if (!ports)
+	if (NULL == ports) {
 		setportent ();
+	}

-	if (!ports) {
+	if (NULL == ports) {
 		errno = saveerr;
 		return 0;
 	}
@@ -150,12 +157,13 @@ static struct port *getportent (void)
 	 * is a '\n'.  Lines which begin with '#' are all ignored.
 	 */

-	if (fgets (buf, sizeof buf, ports) == 0) {
+	if (fgets (buf, (int) sizeof buf, ports) == 0) {
 		errno = saveerr;
 		return 0;
 	}
-	if (buf[0] == '#')
+	if ('#' == buf[0]) {
 		goto again;
+	}

 	/*
 	 * Get the name of the TTY device.  It is the first colon
@@ -169,19 +177,24 @@ static struct port *getportent (void)
 	port.pt_names = ttys;
 	for (cp = buf, j = 0; j < PORT_TTY; j++) {
 		port.pt_names[j] = cp;
-		while (*cp && *cp != ':' && *cp != ',')
+		while (('\0' != *cp) && (':' != *cp) && (',' != *cp)) {
 			cp++;
+		}

-		if (!*cp)
+		if ('\0' == *cp) {
 			goto again;	/* line format error */
+		}

-		if (*cp == ':')	/* end of tty name list */
+		if (':' == *cp) {	/* end of tty name list */
 			break;
+		}

-		if (*cp == ',')	/* end of current tty name */
+		if (',' == *cp) {	/* end of current tty name */
 			*cp++ = '\0';
+		}
 	}
-	*cp++ = 0;
+	*cp = '\0';
+	cp++;
 	port.pt_names[j + 1] = (char *) 0;

 	/*
@@ -191,24 +204,29 @@ static struct port *getportent (void)
 	 * The last entry in the list is a (char *) 0 pointer.
 	 */

-	if (*cp != ':') {
+	if (':' != *cp) {
 		port.pt_users = users;
 		port.pt_users[0] = cp;

-		for (j = 1; *cp != ':'; cp++) {
-			if (*cp == ',' && j < PORT_IDS) {
-				*cp++ = 0;
-				port.pt_users[j++] = cp;
+		for (j = 1; ':' != *cp; cp++) {
+			if ((',' == *cp) && (j < PORT_IDS)) {
+				*cp = '\0';
+				cp++;
+				port.pt_users[j] = cp;
+				j++;
 			}
 		}
 		port.pt_users[j] = 0;
-	} else
+	} else {
 		port.pt_users = 0;
+	}

-	if (*cp != ':')
+	if (':' != *cp) {
 		goto again;
+	}

-	*cp++ = 0;
+	*cp = '\0';
+	cp++;

 	/*
 	 * Get the list of valid times.  The times field is the third
@@ -223,7 +241,7 @@ static struct port *getportent (void)
 	 * the starting time.  Days are presumed to wrap at 0000.
 	 */

-	if (*cp == '\0') {
+	if ('\0' == *cp) {
 		port.pt_times = 0;
 		return &port;
 	}
@@ -234,7 +252,7 @@ static struct port *getportent (void)
 	 * Get the next comma separated entry
 	 */

-	for (j = 0; *cp && j < PORT_TIMES; j++) {
+	for (j = 0; ('\0' != *cp) && (j < PORT_TIMES); j++) {

 		/*
 		 * Start off with no days of the week
@@ -248,7 +266,9 @@ static struct port *getportent (void)
 		 * week or the other two values.
 		 */

-		for (i = 0; cp[i] && cp[i + 1] && isalpha (cp[i]); i += 2) {
+		for (i = 0;
+		     ('\0' != cp[i]) && ('\0' != cp[i + 1]) && isalpha (cp[i]);
+		     i += 2) {
 			switch ((cp[i] << 8) | (cp[i + 1])) {
 			case ('S' << 8) | 'u':
 				port.pt_times[j].t_days |= 01;
@@ -287,8 +307,9 @@ static struct port *getportent (void)
 		 * The default is 'Al' if no days were seen.
 		 */

-		if (i == 0)
+		if (0 == i) {
 			port.pt_times[j].t_days = 0177;
+		}

 		/*
 		 * The start and end times are separated from each
@@ -296,19 +317,27 @@ static struct port *getportent (void)
 		 * representing the times of day.
 		 */

-		for (dtime = 0; cp[i] && isdigit (cp[i]); i++)
+		for (dtime = 0; ('\0' != cp[i]) && isdigit (cp[i]); i++) {
 			dtime = dtime * 10 + cp[i] - '0';
+		}

-		if (cp[i] != '-' || dtime > 2400 || dtime % 100 > 59)
+		if (('-' != cp[i]) || (dtime > 2400) || ((dtime % 100) > 59)) {
 			goto again;
+		}
 		port.pt_times[j].t_start = dtime;
 		cp = cp + i + 1;

-		for (dtime = i = 0; cp[i] && isdigit (cp[i]); i++)
+		for (dtime = 0, i = 0;
+		     ('\0' != cp[i]) && isdigit (cp[i]);
+		     i++) {
 			dtime = dtime * 10 + cp[i] - '0';
+		}

-		if ((cp[i] != ',' && cp[i]) || dtime > 2400 || dtime % 100 > 59)
+		if (   ((',' != cp[i]) && ('\0' != cp[i]))
+		    || (dtime > 2400)
+		    || ((dtime % 100) > 59)) {
 			goto again;
+		}

 		port.pt_times[j].t_end = dtime;
 		cp = cp + i + 1;
@@ -340,24 +369,32 @@ static struct port *getttyuser (const char *tty, const char *user)

 	setportent ();

-	while ((port = getportent ())) {
-		if (port->pt_names == 0 || port->pt_users == 0)
+	while ((port = getportent ()) != NULL) {
+		if (   (0 == port->pt_names)
+		    || (0 == port->pt_users)) {
 			continue;
+		}

-		for (i = 0; port->pt_names[i]; i++)
-			if (portcmp (port->pt_names[i], tty) == 0)
+		for (i = 0; NULL != port->pt_names[i]; i++) {
+			if (portcmp (port->pt_names[i], tty) == 0) {
 				break;
+			}
+		}

-		if (port->pt_names[i] == 0)
+		if (port->pt_names[i] == 0) {
 			continue;
+		}

-		for (j = 0; port->pt_users[j]; j++)
-			if (strcmp (user, port->pt_users[j]) == 0 ||
-			    strcmp (port->pt_users[j], "*") == 0)
+		for (j = 0; NULL != port->pt_users[j]; j++) {
+			if (   (strcmp (user, port->pt_users[j]) == 0)
+			    || (strcmp (port->pt_users[j], "*") == 0)) {
 				break;
+			}
+		}

-		if (port->pt_users[j] != 0)
+		if (port->pt_users[j] != 0) {
 			break;
+		}
 	}
 	endportent ();
 	return port;
@@ -370,7 +407,7 @@ static struct port *getttyuser (const char *tty, const char *user)
 *	the user name and TTY given.
 */

-int isttytime (const char *id, const char *port, time_t when)
+bool isttytime (const char *id, const char *port, time_t when)
 {
 	int i;
 	int dtime;
@@ -379,24 +416,27 @@ int isttytime (const char *id, const char *port, time_t when)

 	/*
 	 * Try to find a matching entry for this user.  Default to
-	 * letting the user in - there are pleny of ways to have an
+	 * letting the user in - there are plenty of ways to have an
 	 * entry to match all users.
 	 */

-	if (!(pp = getttyuser (port, id)))
-		return 1;
+	pp = getttyuser (port, id);
+	if (NULL == pp) {
+		return true;
+	}

 	/*
 	 * The entry is there, but has no time entries - don't
 	 * ever let them login.
 	 */

-	if (pp->pt_times == 0)
-		return 0;
+	if (0 == pp->pt_times) {
+		return false;
+	}

 	/*
 	 * The current time is converted to HHMM format for
-	 * comparision against the time values in the TTY entry.
+	 * comparison against the time values in the TTY entry.
 	 */

 	tm = localtime (&when);
@@ -405,22 +445,25 @@ int isttytime (const char *id, const char *port, time_t when)
 	/*
 	 * Each time entry is compared against the current
 	 * time.  For entries with the start after the end time,
-	 * the comparision is made so that the time is between
+	 * the comparison is made so that the time is between
 	 * midnight and either the start or end time.
 	 */

 	for (i = 0; pp->pt_times[i].t_start != -1; i++) {
-		if (!(pp->pt_times[i].t_days & PORT_DAY (tm->tm_wday)))
+		if (!(pp->pt_times[i].t_days & PORT_DAY (tm->tm_wday))) {
 			continue;
+		}

 		if (pp->pt_times[i].t_start <= pp->pt_times[i].t_end) {
-			if (dtime >= pp->pt_times[i].t_start &&
-			    dtime <= pp->pt_times[i].t_end)
-				return 1;
+			if (   (dtime >= pp->pt_times[i].t_start)
+			    && (dtime <= pp->pt_times[i].t_end)) {
+				return true;
+			}
 		} else {
-			if (dtime >= pp->pt_times[i].t_start ||
-			    dtime <= pp->pt_times[i].t_end)
-				return 1;
+			if (   (dtime >= pp->pt_times[i].t_start)
+			    || (dtime <= pp->pt_times[i].t_end)) {
+				return true;
+			}
 		}
 	}

@@ -429,5 +472,6 @@ int isttytime (const char *id, const char *port, time_t when)
 	 * be let in right now.
 	 */

-	return 0;
+	return false;
 }
+
--- a/lib/prototypes.h
+++ b/lib/prototypes.h
@@ -2,7 +2,7 @@
 * Copyright (c) 1990 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2003 - 2006, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -42,12 +42,15 @@
 #ifndef _PROTOTYPES_H
 #define _PROTOTYPES_H

+#include <config.h>
+
 #include <sys/stat.h>
-#if HAVE_UTMPX_H
+#ifdef USE_UTMPX
 #include <utmpx.h>
 #else
 #include <utmp.h>
 #endif
+#include <sys/types.h>
 #include <pwd.h>
 #include <grp.h>
 #include <shadow.h>
@@ -56,41 +59,80 @@
 #include "defines.h"
 #include "commonio.h"

+extern /*@observer@*/ const char *Prog;
+
 /* addgrps.c */
+#if defined (HAVE_SETGROUPS) && ! defined (USE_PAM)
 extern int add_groups (const char *);
-extern void add_cons_grps (void);
+#endif

 /* age.c */
-extern void agecheck (const struct passwd *, const struct spwd *);
-extern int expire (const struct passwd *, const struct spwd *);
-extern int isexpired (const struct passwd *, const struct spwd *);
+extern void agecheck (/*@null@*/const struct spwd *);
+extern int expire (const struct passwd *, /*@null@*/const struct spwd *);
+/* isexpired.c */
+extern int isexpired (const struct passwd *, /*@null@*/const struct spwd *);

 /* basename() renamed to Basename() to avoid libc name space confusion */
 /* basename.c */
-extern char *Basename (char *str);
+extern /*@observer@*/const char *Basename (const char *str);

 /* chowndir.c */
-extern int chown_tree (const char *, uid_t, uid_t, gid_t, gid_t);
+extern int chown_tree (const char *root,
+                       uid_t old_uid, uid_t new_uid,
+                       gid_t old_gid, gid_t new_gid);

 /* chowntty.c */
-extern void chown_tty (const char *, const struct passwd *);
+extern void chown_tty (const struct passwd *);
+
+/* cleanup.c */
+typedef /*@null@*/void (*cleanup_function) (/*@null@*/void *arg);
+void add_cleanup (/*@notnull@*/cleanup_function pcf, /*@null@*/void *arg);
+void del_cleanup (/*@notnull@*/cleanup_function pcf);
+void do_cleanups (void);
+
+/* cleanup_group.c */
+struct cleanup_info_mod {
+	char *audit_msg;
+	char *action;
+	/*@observer@*/const char *name;
+};
+void cleanup_report_add_group (void *group_name);
+void cleanup_report_add_group_group (void *group_name);
+#ifdef SHADOWGRP
+void cleanup_report_add_group_gshadow (void *group_name);
+#endif
+void cleanup_report_del_group (void *group_name);
+void cleanup_report_del_group_group (void *group_name);
+#ifdef SHADOWGRP
+void cleanup_report_del_group_gshadow (void *group_name);
+#endif
+void cleanup_report_mod_passwd (void *cleanup_info);
+void cleanup_report_mod_group (void *cleanup_info);
+void cleanup_report_mod_gshadow (void *cleanup_info);
+void cleanup_unlock_group (/*@null@*/void *unused);
+#ifdef SHADOWGRP
+void cleanup_unlock_gshadow (/*@null@*/void *unused);
+#endif
+void cleanup_unlock_passwd (/*@null@*/void *unused);

 /* console.c */
-extern int console (const char *);
+extern bool console (const char *);

 /* copydir.c */
 extern int copy_tree (const char *src_root, const char *dst_root,
-                      long int uid, long int gid);
-extern int remove_tree (const char *root);
+                      bool copy_root,
+                      bool reset_selinux,
+                      uid_t old_uid, uid_t new_uid,
+                      gid_t old_gid, gid_t new_gid);

 /* encrypt.c */
-extern char *pw_encrypt (const char *, const char *);
+extern /*@exposed@*//*@null@*/char *pw_encrypt (const char *, const char *);

 /* entry.c */
 extern void pw_entry (const char *, struct passwd *);

 /* env.c */
-extern void addenv (const char *, const char *);
+extern void addenv (const char *, /*@null@*/const char *);
 extern void initenv (void);
 extern void set_env (int, char *const *);
 extern void sanitize_env (void);
@@ -99,52 +141,100 @@ extern void sanitize_env (void);
 extern void change_field (char *, size_t, const char *);
 extern int valid_field (const char *, const char *);

-/* find_new_ids.c */
-extern int find_new_uid (int sys_user, uid_t *uid, uid_t const *preferred_uid);
-extern int find_new_gid (int sys_group, gid_t *gid, gid_t const *preferred_gid);
+/* find_new_gid.c */
+extern int find_new_gid (bool sys_group,
+                         gid_t *gid,
+                         /*@null@*/gid_t const *preferred_gid);
+
+/* find_new_uid.c */
+extern int find_new_uid (bool sys_user,
+                         uid_t *uid,
+                         /*@null@*/uid_t const *preferred_uid);
+
+#ifdef ENABLE_SUBIDS
+/* find_new_sub_gids.c */
+extern int find_new_sub_gids (const char *owner,
+			      gid_t *range_start, unsigned long *range_count);
+
+/* find_new_sub_uids.c */
+extern int find_new_sub_uids (const char *owner,
+			      uid_t *range_start, unsigned long *range_count);
+#endif				/* ENABLE_SUBIDS */
+
+
+/* get_gid.c */
+extern int get_gid (const char *gidstr, gid_t *gid);
+
+/* getgr_nam_gid.c */
+extern /*@only@*//*@null@*/struct group *getgr_nam_gid (/*@null@*/const char *grname);

 /* getlong.c */
-extern int getlong(const char *numstr, long int *result);
+extern int getlong (const char *numstr, /*@out@*/long int *result);
+
+/* get_pid.c */
+extern int get_pid (const char *pidstr, pid_t *pid);
+
+/* getrange */
+extern int getrange (char *range,
+                     unsigned long *min, bool *has_min,
+                     unsigned long *max, bool *has_max);
+
+/* get_uid.c */
+extern int get_uid (const char *uidstr, uid_t *uid);
+
+/* getulong.c */
+extern int getulong (const char *numstr, /*@out@*/unsigned long int *result);

 /* fputsx.c */
-extern char *fgetsx (char *, int, FILE *);
+extern /*@null@*/char *fgetsx (/*@returned@*/ /*@out@*/char *, int, FILE *);
 extern int fputsx (const char *, FILE *);

 /* groupio.c */
 extern void __gr_del_entry (const struct commonio_entry *ent);
-extern struct commonio_db *__gr_get_db (void);
-extern struct commonio_entry *__gr_get_head (void);
+extern /*@observer@*/const struct commonio_db *__gr_get_db (void);
+extern /*@dependent@*/ /*@null@*/struct commonio_entry *__gr_get_head (void);
 extern void __gr_set_changed (void);

 /* groupmem.c */
-extern struct group *__gr_dup (const struct group *grent);
+extern /*@null@*/ /*@only@*/struct group *__gr_dup (const struct group *grent);
+extern void gr_free (/*@out@*/ /*@only@*/struct group *grent);

 /* hushed.c */
-extern int hushed (const struct passwd *);
+extern bool hushed (const char *username);

 /* audit_help.c */
 #ifdef WITH_AUDIT
 extern int audit_fd;
 extern void audit_help_open (void);
+/* Use AUDIT_NO_ID when a name is provided to audit_logger instead of an ID */
+#define AUDIT_NO_ID	((unsigned int) -1)
+typedef enum {
+	SHADOW_AUDIT_FAILURE = 0,
+	SHADOW_AUDIT_SUCCESS = 1} shadow_audit_result;
 extern void audit_logger (int type, const char *pgname, const char *op,
-			  const char *name, unsigned int id, int result);
+                          const char *name, unsigned int id,
+                          shadow_audit_result result);
+void audit_logger_message (const char *message, shadow_audit_result result);
 #endif

 /* limits.c */
+#ifndef USE_PAM
 extern void setup_limits (const struct passwd *);
+#endif

 /* list.c */
-extern char **add_list (char **, const char *);
-extern char **del_list (char **, const char *);
-extern char **dup_list (char *const *);
-extern int is_on_list (char *const *, const char *);
-extern char **comma_to_list (const char *);
+extern /*@only@*/ /*@out@*/char **add_list (/*@returned@*/ /*@only@*/char **, const char *);
+extern /*@only@*/ /*@out@*/char **del_list (/*@returned@*/ /*@only@*/char **, const char *);
+extern /*@only@*/ /*@out@*/char **dup_list (char *const *);
+extern bool is_on_list (char *const *list, const char *member);
+extern /*@only@*/char **comma_to_list (const char *);

 /* log.c */
-extern void dolastlog (struct lastlog *ll,
-                       const struct passwd *pw,
-                       const char *line,
-                       const char *host);
+extern void dolastlog (
+	struct lastlog *ll,
+	const struct passwd *pw,
+	/*@unique@*/const char *line,
+	/*@unique@*/const char *host);

 /* login_nopam.c */
 extern int login_access (const char *user, const char *from);
@@ -159,22 +249,37 @@ extern void mailcheck (void);
 extern void motd (void);

 /* myname.c */
-extern struct passwd *get_my_pwent (void);
+extern /*@null@*//*@only@*/struct passwd *get_my_pwent (void);
+
+/* pam_pass_non_interractive.c */
+#ifdef USE_PAM
+extern int do_pam_passwd_non_interractive (const char *pam_service,
+                                           const char *username,
+                                           const char* password);
+#endif				/* USE_PAM */

 /* obscure.c */
-extern int obscure (const char *, const char *, const struct passwd *);
+#ifndef USE_PAM
+extern bool obscure (const char *, const char *, const struct passwd *);
+#endif

 /* pam_pass.c */
-extern void do_pam_passwd (const char *, int, int);
+#ifdef USE_PAM
+extern void do_pam_passwd (const char *user, bool silent, bool change_expired);
+#endif

 /* port.c */
-extern int isttytime (const char *, const char *, time_t);
+extern bool isttytime (const char *, const char *, time_t);

 /* pwd2spwd.c */
+#ifndef USE_PAM
 extern struct spwd *pwd_to_spwd (const struct passwd *);
+#endif

 /* pwdcheck.c */
+#ifndef USE_PAM
 extern void passwd_check (const char *, const char *, const char *);
+#endif

 /* pwd_init.c */
 extern void pwd_init (void);
@@ -182,21 +287,45 @@ extern void pwd_init (void);
 /* pwio.c */
 extern void __pw_del_entry (const struct commonio_entry *ent);
 extern struct commonio_db *__pw_get_db (void);
-extern struct commonio_entry *__pw_get_head (void);
+extern /*@dependent@*/ /*@null@*/struct commonio_entry *__pw_get_head (void);

 /* pwmem.c */
-extern struct passwd *__pw_dup (const struct passwd *pwent);
+extern /*@null@*/ /*@only@*/struct passwd *__pw_dup (const struct passwd *pwent);
+extern void pw_free (/*@out@*/ /*@only@*/struct passwd *pwent);
+
+/* remove_tree.c */
+extern int remove_tree (const char *root, bool remove_root);

 /* rlogin.c */
-extern int do_rlogin (const char *, char *, int, char *, int);
+extern int do_rlogin (const char *remote_host, char *name, size_t namelen,
+                      char *term, size_t termlen);
+
+/* root_flag.c */
+extern void process_root_flag (const char* short_opt, int argc, char **argv);

 /* salt.c */
-extern char *crypt_make_salt (const char *meth, void *arg);
+extern /*@observer@*/const char *crypt_make_salt (/*@null@*//*@observer@*/const char *meth, /*@null@*/void *arg);
+
+/* selinux.c */
+#ifdef WITH_SELINUX
+extern int set_selinux_file_context (const char *dst_name);
+extern int reset_selinux_file_context (void);
+#endif
+
+/* semanage.c */
+#ifdef WITH_SELINUX
+extern int set_seuser(const char *login_name, const char *seuser_name);
+extern int del_seuser(const char *login_name);
+#endif

 /* setugid.c */
-extern int setup_groups (const struct passwd *);
-extern int change_uid (const struct passwd *);
-extern int setup_uid_gid (const struct passwd *, int);
+extern int setup_groups (const struct passwd *info);
+extern int change_uid (const struct passwd *info);
+#if (defined HAVE_INITGROUPS) && (! defined USE_PAM)
+extern int setup_uid_gid (const struct passwd *info, bool is_console);
+#else
+extern int setup_uid_gid (const struct passwd *info);
+#endif

 /* setup.c */
 extern void setup (struct passwd *);
@@ -210,30 +339,46 @@ extern struct group *sgetgrent (const char *buf);
 /* sgetpwent.c */
 extern struct passwd *sgetpwent (const char *buf);

+/* sgetspent.c */
+#ifndef HAVE_SGETSPENT
+extern struct spwd *sgetspent (const char *string);
+#endif
+
 /* sgroupio.c */
 extern void __sgr_del_entry (const struct commonio_entry *ent);
-extern struct sgrp *__sgr_dup (const struct sgrp *sgent);
-extern struct commonio_entry *__sgr_get_head (void);
+extern /*@null@*/ /*@only@*/struct sgrp *__sgr_dup (const struct sgrp *sgent);
+extern void sgr_free (/*@out@*/ /*@only@*/struct sgrp *sgent);
+extern /*@dependent@*/ /*@null@*/struct commonio_entry *__sgr_get_head (void);
 extern void __sgr_set_changed (void);

 /* shadowio.c */
-extern struct commonio_entry *__spw_get_head (void);
+extern /*@dependent@*/ /*@null@*/struct commonio_entry *__spw_get_head (void);
 extern void __spw_del_entry (const struct commonio_entry *ent);

 /* shadowmem.c */
-extern struct spwd *__spw_dup (const struct spwd *spent);
+extern /*@null@*/ /*@only@*/struct spwd *__spw_dup (const struct spwd *spent);
+extern void spw_free (/*@out@*/ /*@only@*/struct spwd *spent);

 /* shell.c */
-extern int shell (const char *, const char *, char *const *);
+extern int shell (const char *file, /*@null@*/const char *arg, char *const envp[]);
+
+/* spawn.c */
+extern int run_command (const char *cmd, const char *argv[],
+                        /*@null@*/const char *envp[], /*@out@*/int *status);

 /* strtoday.c */
 extern long strtoday (const char *);

 /* suauth.c */
-extern int check_su_auth (const char *actual_id, const char *wanted_id);
+extern int check_su_auth (const char *actual_id,
+                          const char *wanted_id,
+                          bool su_to_root);

 /* sulog.c */
-extern void sulog (const char *, int, const char *, const char *);
+extern void sulog (const char *tty,
+                   bool success,
+                   const char *oldname,
+                   const char *name);

 /* sub.c */
 extern void subsystem (const struct passwd *);
@@ -242,34 +387,51 @@ extern void subsystem (const struct passwd *);
 extern void ttytype (const char *);

 /* tz.c */
-extern char *tz (const char *);
+#ifndef USE_PAM
+extern /*@observer@*/const char *tz (const char *);
+#endif

 /* ulimit.c */
-extern void set_filesize_limit (int);
+extern int set_filesize_limit (int blocks);
+
+/* user_busy.c */
+extern int user_busy (const char *name, uid_t uid);

 /* utmp.c */
-extern void checkutmp (int);
-extern void setutmp (const char *, const char *, const char *);
+extern /*@null@*/struct utmp *get_current_utmp (void);
+extern struct utmp *prepare_utmp (const char *name,
+                                  const char *line,
+                                  const char *host,
+                                  /*@null@*/const struct utmp *ut);
+extern int setutmp (struct utmp *ut);
+#ifdef USE_UTMPX
+extern struct utmpx *prepare_utmpx (const char *name,
+                                    const char *line,
+                                    const char *host,
+                                    /*@null@*/const struct utmp *ut);
+extern int setutmpx (struct utmpx *utx);
+#endif				/* USE_UTMPX */

 /* valid.c */
-extern int valid (const char *, const struct passwd *);
+extern bool valid (const char *, const struct passwd *);

 /* xmalloc.c */
-extern char *xmalloc (size_t);
-extern char *xstrdup (const char *);
+extern /*@maynotreturn@*/ /*@only@*//*@out@*//*@notnull@*/char *xmalloc (size_t size)
+  /*@ensures MaxSet(result) == (size - 1); @*/;
+extern /*@maynotreturn@*/ /*@only@*//*@notnull@*/char *xstrdup (const char *);

 /* xgetpwnam.c */
-extern struct passwd *xgetpwnam (const char *);
+extern /*@null@*/ /*@only@*/struct passwd *xgetpwnam (const char *);
 /* xgetpwuid.c */
-extern struct passwd *xgetpwuid (uid_t);
+extern /*@null@*/ /*@only@*/struct passwd *xgetpwuid (uid_t);
 /* xgetgrnam.c */
-extern struct group *xgetgrnam (const char *);
+extern /*@null@*/ /*@only@*/struct group *xgetgrnam (const char *);
 /* xgetgrgid.c */
-extern struct group *xgetgrgid (gid_t);
+extern /*@null@*/ /*@only@*/struct group *xgetgrgid (gid_t);
 /* xgetspnam.c */
-extern struct spwd *xgetspnam(const char *);
+extern /*@null@*/ /*@only@*/struct spwd *xgetspnam(const char *);

 /* yesno.c */
-extern int yes_or_no (int read_only);
+extern bool yes_or_no (bool read_only);

 #endif				/* _PROTOTYPES_H */
--- a/lib/pwauth.c
+++ b/lib/pwauth.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1992 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2003 - 2006, Tomasz Kłoczko
- * Copyright (c) 2008       , Nicolas François
+ * Copyright (c) 2008 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -54,8 +54,8 @@ static const char *PROMPT = gettext_noop ("Password: ");
 static const char *PROMPT = gettext_noop ("%s's Password: ");
 #endif

-int wipe_clear_pass = 1;
-char *clear_pass = NULL;
+bool wipe_clear_pass = true;
+/*@null@*/char *clear_pass = NULL;

 /*
 * pw_auth - perform getpass/crypt authentication
@@ -65,16 +65,19 @@ char *clear_pass = NULL;
 *	compared.
 */

-int
-pw_auth (const char *cipher, const char *user, int reason, const char *input)
+int pw_auth (const char *cipher,
+             const char *user,
+             int reason,
+             /*@null@*/const char *input)
 {
 	char prompt[1024];
 	char *clear = NULL;
 	const char *cp;
+	const char *encrypted;
 	int retval;

 #ifdef	SKEY
-	int use_skey = 0;
+	bool use_skey = false;
 	char challenge_info[40];
 	struct skey skey;
 #endif
@@ -83,15 +86,17 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 * There are programs for adding and deleting authentication data.
 	 */

-	if (reason == PW_ADD || reason == PW_DELETE)
+	if ((PW_ADD == reason) || (PW_DELETE == reason)) {
 		return 0;
+	}

 	/*
 	 * There are even programs for changing the user name ...
 	 */

-	if (reason == PW_CHANGE && input != (char *) 0)
+	if ((PW_CHANGE == reason) && (NULL != input)) {
 		return 0;
+	}

 	/*
 	 * WARNING:
@@ -102,8 +107,9 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 * revisited.
 	 */

-	if (reason == PW_CHANGE && getuid () == 0)
+	if ((PW_CHANGE == reason) && (getuid () == 0)) {
 		return 0;
+	}

 	/*
 	 * WARNING:
@@ -114,8 +120,9 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 * matter.
 	 */

-	if (cipher == (char *) 0 || *cipher == '\0')
+	if ((NULL == cipher) || ('\0' == *cipher)) {
 		return 0;
+	}

 #ifdef	SKEY
 	/*
@@ -132,8 +139,9 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 #  define skeychallenge(s,u,c) skeychallenge(s,u,c,sizeof(c))
 # endif

-	if (skeychallenge (&skey, user, challenge_info) == 0)
-		use_skey = 1;
+	if (skeychallenge (&skey, user, challenge_info) == 0) {
+		use_skey = true;
+	}
 #endif

 	/*
@@ -141,17 +149,20 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 * get the cleartext password for us.
 	 */

-	if (reason != PW_FTP && reason != PW_REXEC && !input) {
-		if (!(cp = getdef_str ("LOGIN_STRING")))
+	if ((PW_FTP != reason) && (PW_REXEC != reason) && (NULL == input)) {
+		cp = getdef_str ("LOGIN_STRING");
+		if (NULL == cp) {
 			cp = _(PROMPT);
+		}
 #ifdef	SKEY
-		if (use_skey)
+		if (use_skey) {
 			printf ("[%s]\n", challenge_info);
+		}
 #endif

 		snprintf (prompt, sizeof prompt, cp, user);
 		clear = getpass (prompt);
-		if (!clear) {
+		if (NULL == clear) {
 			static char c[1];

 			c[0] = '\0';
@@ -167,7 +178,12 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 * the results there as well.
 	 */

-	retval = strcmp (pw_encrypt (input, cipher), cipher);
+	encrypted = pw_encrypt (input, cipher);
+	if (NULL != encrypted) {
+		retval = strcmp (encrypted, cipher);
+	} else {
+		retval = -1;
+	}

 #ifdef  SKEY
 	/*
@@ -177,9 +193,9 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 * ...Re-prompt, with echo on.
 	 * -- AR 8/22/1999
 	 */
-	if (retval && !input[0] && (use_skey)) {
+	if ((0 != retval) && ('\0' == input[0]) && use_skey) {
 		clear = getpass (prompt);
-		if (!clear) {
+		if (NULL == clear) {
 			static char c[1];

 			c[0] = '\0';
@@ -188,13 +204,15 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 		input = clear;
 	}

-	if (retval && use_skey) {
+	if ((0 != retval) && use_skey) {
 		int passcheck = -1;

-		if (skeyverify (&skey, input) == 0)
+		if (skeyverify (&skey, input) == 0) {
 			passcheck = skey.n;
-		if (passcheck > 0)
+		}
+		if (passcheck > 0) {
 			retval = 0;
+		}
 	}
 #endif

@@ -206,8 +224,9 @@ pw_auth (const char *cipher, const char *user, int reason, const char *input)
 	 */

 	clear_pass = clear;
-	if (wipe_clear_pass && clear && *clear)
+	if (wipe_clear_pass && (NULL != clear) && ('\0' != *clear)) {
 		strzero (clear);
+	}
 	return retval;
 }
 #else				/* !USE_PAM */
--- a/lib/pwauth.h
+++ b/lib/pwauth.h
@@ -2,6 +2,7 @@
 * Copyright (c) 1992 - 1993, Julianne Frances Haugh
 * Copyright (c) 1996 - 1997, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2009       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,7 +35,10 @@
 */

 #ifndef USE_PAM
-int pw_auth (const char *cipher, const char *user, int flag, const char *input);
+int pw_auth (const char *cipher,
+             const char *user,
+             int flag,
+             /*@null@*/const char *input);
 #endif				/* !USE_PAM */

 /*
--- a/lib/pwio.c
+++ b/lib/pwio.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -42,23 +42,18 @@
 #include "commonio.h"
 #include "pwio.h"

-static void *passwd_dup (const void *ent)
+static /*@null@*/ /*@only@*/void *passwd_dup (const void *ent)
 {
 	const struct passwd *pw = ent;

 	return __pw_dup (pw);
 }

-static void passwd_free (void *ent)
+static void passwd_free (/*@out@*/ /*@only@*/void *ent)
 {
 	struct passwd *pw = ent;

-	free (pw->pw_name);
-	free (pw->pw_passwd);
-	free (pw->pw_gecos);
-	free (pw->pw_dir);
-	free (pw->pw_shell);
-	free (pw);
+	pw_free (pw);
 }

 static const char *passwd_getname (const void *ent)
@@ -77,6 +72,17 @@ static int passwd_put (const void *ent, FILE * file)
 {
 	const struct passwd *pw = ent;

+	if (   (NULL == pw)
+	    || (valid_field (pw->pw_name, ":\n") == -1)
+	    || (valid_field (pw->pw_passwd, ":\n") == -1)
+	    || (pw->pw_uid == (uid_t)-1)
+	    || (pw->pw_gid == (gid_t)-1)
+	    || (valid_field (pw->pw_gecos, ":\n") == -1)
+	    || (valid_field (pw->pw_dir, ":\n") == -1)
+	    || (valid_field (pw->pw_shell, ":\n") == -1)) {
+		return -1;
+	}
+
 	return (putpwent (pw, file) == -1) ? -1 : 0;
 }

@@ -102,17 +108,22 @@ static struct commonio_db passwd_db = {
 	NULL,			/* head */
 	NULL,			/* tail */
 	NULL,			/* cursor */
-	0,			/* changed */
-	0,			/* isopen */
-	0,			/* locked */
-	0			/* readonly */
+	false,			/* changed */
+	false,			/* isopen */
+	false,			/* locked */
+	false			/* readonly */
 };

-int pw_name (const char *filename)
+int pw_setdbname (const char *filename)
 {
 	return commonio_setname (&passwd_db, filename);
 }

+/*@observer@*/const char *pw_dbname (void)
+{
+	return passwd_db.filename;
+}
+
 int pw_lock (void)
 {
 	return commonio_lock (&passwd_db);
@@ -123,12 +134,12 @@ int pw_open (int mode)
 	return commonio_open (&passwd_db, mode);
 }

-const struct passwd *pw_locate (const char *name)
+/*@observer@*/ /*@null@*/const struct passwd *pw_locate (const char *name)
 {
 	return commonio_locate (&passwd_db, name);
 }

-const struct passwd *pw_locate_uid (uid_t uid)
+/*@observer@*/ /*@null@*/const struct passwd *pw_locate_uid (uid_t uid)
 {
 	const struct passwd *pwd;

@@ -155,7 +166,7 @@ int pw_rewind (void)
 	return commonio_rewind (&passwd_db);
 }

-const struct passwd *pw_next (void)
+/*@observer@*/ /*@null@*/const struct passwd *pw_next (void)
 {
 	return commonio_next (&passwd_db);
 }
@@ -170,7 +181,7 @@ int pw_unlock (void)
 	return commonio_unlock (&passwd_db);
 }

-struct commonio_entry *__pw_get_head (void)
+/*@null@*/struct commonio_entry *__pw_get_head (void)
 {
 	return passwd_db.head;
 }
--- a/lib/pwio.h
+++ b/lib/pwio.h
@@ -31,17 +31,25 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

+/* $Id$ */
+#ifndef _PWIO_H
+#define _PWIO_H
+
+#include <sys/types.h>
 #include <pwd.h>
+
 extern int pw_close (void);
-extern const struct passwd *pw_locate (const char *);
-extern const struct passwd *pw_locate_uid (uid_t uid);
+extern /*@observer@*/ /*@null@*/const struct passwd *pw_locate (const char *name);
+extern /*@observer@*/ /*@null@*/const struct passwd *pw_locate_uid (uid_t uid);
 extern int pw_lock (void);
-extern int pw_name (const char *);
-extern const struct passwd *pw_next (void);
-extern int pw_open (int);
-extern int pw_remove (const char *);
+extern int pw_setdbname (const char *filename);
+extern /*@observer@*/const char *pw_dbname (void);
+extern /*@observer@*/ /*@null@*/const struct passwd *pw_next (void);
+extern int pw_open (int mode);
+extern int pw_remove (const char *name);
 extern int pw_rewind (void);
 extern int pw_unlock (void);
-extern int pw_update (const struct passwd *);
+extern int pw_update (const struct passwd *pw);
 extern int pw_sort (void);

+#endif
--- a/lib/pwmem.c
+++ b/lib/pwmem.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007       , Nicolas François
+ * Copyright (c) 2007 - 2013, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -35,29 +35,82 @@

 #ident "$Id$"

-#include "prototypes.h"
-#include "defines.h"
-#include <pwd.h>
 #include <stdio.h>
+#include "defines.h"
+#include "prototypes.h"
 #include "pwio.h"

-struct passwd *__pw_dup (const struct passwd *pwent)
+/*@null@*/ /*@only@*/struct passwd *__pw_dup (const struct passwd *pwent)
 {
 	struct passwd *pw;

-	if (!(pw = (struct passwd *) malloc (sizeof *pw)))
+	pw = (struct passwd *) malloc (sizeof *pw);
+	if (NULL == pw) {
 		return NULL;
-	*pw = *pwent;
-	if (!(pw->pw_name = strdup (pwent->pw_name)))
+	}
+	/* The libc might define other fields. They won't be copied. */
+	memset (pw, 0, sizeof *pw);
+	pw->pw_uid = pwent->pw_uid;
+	pw->pw_gid = pwent->pw_gid;
+	/*@-mustfreeonly@*/
+	pw->pw_name = strdup (pwent->pw_name);
+	/*@=mustfreeonly@*/
+	if (NULL == pw->pw_name) {
+		free(pw);
 		return NULL;
-	if (!(pw->pw_passwd = strdup (pwent->pw_passwd)))
+	}
+	/*@-mustfreeonly@*/
+	pw->pw_passwd = strdup (pwent->pw_passwd);
+	/*@=mustfreeonly@*/
+	if (NULL == pw->pw_passwd) {
+		free(pw->pw_name);
+		free(pw);
 		return NULL;
-	if (!(pw->pw_gecos = strdup (pwent->pw_gecos)))
+	}
+	/*@-mustfreeonly@*/
+	pw->pw_gecos = strdup (pwent->pw_gecos);
+	/*@=mustfreeonly@*/
+	if (NULL == pw->pw_gecos) {
+		free(pw->pw_passwd);
+		free(pw->pw_name);
+		free(pw);
 		return NULL;
-	if (!(pw->pw_dir = strdup (pwent->pw_dir)))
+	}
+	/*@-mustfreeonly@*/
+	pw->pw_dir = strdup (pwent->pw_dir);
+	/*@=mustfreeonly@*/
+	if (NULL == pw->pw_dir) {
+		free(pw->pw_gecos);
+		free(pw->pw_passwd);
+		free(pw->pw_name);
+		free(pw);
 		return NULL;
-	if (!(pw->pw_shell = strdup (pwent->pw_shell)))
+	}
+	/*@-mustfreeonly@*/
+	pw->pw_shell = strdup (pwent->pw_shell);
+	/*@=mustfreeonly@*/
+	if (NULL == pw->pw_shell) {
+		free(pw->pw_dir);
+		free(pw->pw_gecos);
+		free(pw->pw_passwd);
+		free(pw->pw_name);
+		free(pw);
 		return NULL;
+	}
+
 	return pw;
 }

+void pw_free (/*@out@*/ /*@only@*/struct passwd *pwent)
+{
+	free (pwent->pw_name);
+	if (pwent->pw_passwd) {
+		memzero (pwent->pw_passwd, strlen (pwent->pw_passwd));
+		free (pwent->pw_passwd);
+	}
+	free (pwent->pw_gecos);
+	free (pwent->pw_dir);
+	free (pwent->pw_shell);
+	free (pwent);
+}
+
--- a/lib/selinux.c
+++ b/lib/selinux.c
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2011       , Peter Vrabec <pvrabec@redhat.com>
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ifdef WITH_SELINUX
+
+#include "defines.h"
+
+#include <selinux/selinux.h>
+#include "prototypes.h"
+
+
+static bool selinux_checked = false;
+static bool selinux_enabled;
+
+/*
+ * set_selinux_file_context - Set the security context before any file or
+ *                            directory creation.
+ *
+ *	set_selinux_file_context () should be called before any creation
+ *	of file, symlink, directory, ...
+ *
+ *	Callers may have to Reset SELinux to create files with default
+ *	contexts with reset_selinux_file_context
+ */
+int set_selinux_file_context (const char *dst_name)
+{
+	/*@null@*/security_context_t scontext = NULL;
+
+	if (!selinux_checked) {
+		selinux_enabled = is_selinux_enabled () > 0;
+		selinux_checked = true;
+	}
+
+	if (selinux_enabled) {
+		/* Get the default security context for this file */
+		if (matchpathcon (dst_name, 0, &scontext) < 0) {
+			if (security_getenforce () != 0) {
+				return 1;
+			}
+		}
+		/* Set the security context for the next created file */
+		if (setfscreatecon (scontext) < 0) {
+			if (security_getenforce () != 0) {
+				return 1;
+			}
+		}
+		freecon (scontext);
+	}
+	return 0;
+}
+
+/*
+ * reset_selinux_file_context - Reset the security context to the default
+ *                              policy behavior
+ *
+ *	reset_selinux_file_context () should be called after the context
+ *	was changed with set_selinux_file_context ()
+ */
+int reset_selinux_file_context (void)
+{
+	if (!selinux_checked) {
+		selinux_enabled = is_selinux_enabled () > 0;
+		selinux_checked = true;
+	}
+	if (selinux_enabled) {
+		if (setfscreatecon (NULL) != 0) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+#else				/* !WITH_SELINUX */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* !WITH_SELINUX */
--- a/lib/semanage.c
+++ b/lib/semanage.c
@@ -0,0 +1,378 @@
+/*
+ * Copyright (c) 2010       , Jakub Hrozek <jhrozek@redhat.com>
+ * Copyright (c) 2011       , Peter Vrabec <pvrabec@redhat.com>
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ifdef WITH_SELINUX
+
+#include "defines.h"
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <stdio.h>
+#include <stdarg.h>
+#include <selinux/selinux.h>
+#include <semanage/semanage.h>
+#include "prototypes.h"
+
+
+#ifndef DEFAULT_SERANGE
+#define DEFAULT_SERANGE "s0"
+#endif
+
+
+static void semanage_error_callback (unused void *varg,
+                                     semanage_handle_t *handle,
+                                     const char *fmt, ...)
+{
+	int ret;
+	char * message = NULL;
+	va_list ap;
+
+
+	va_start (ap, fmt);
+	ret = vasprintf (&message, fmt, ap);
+	va_end (ap);
+	if (ret < 0) {
+		/* ENOMEM */
+		return;
+	}
+
+	switch (semanage_msg_get_level (handle)) {
+	case SEMANAGE_MSG_ERR:
+	case SEMANAGE_MSG_WARN:
+		fprintf (stderr, _("[libsemanage]: %s\n"), message);
+		break;
+	case SEMANAGE_MSG_INFO:
+		/* nop */
+		break;
+	}
+
+	free (message);
+}
+
+
+static semanage_handle_t *semanage_init (void)
+{
+	int ret;
+	semanage_handle_t *handle = NULL;
+
+	handle = semanage_handle_create ();
+	if (NULL == handle) {
+		fprintf (stderr,
+		         _("Cannot create SELinux management handle\n"));
+		return NULL;
+	}
+
+	semanage_msg_set_callback (handle, semanage_error_callback, NULL);
+
+	ret = semanage_is_managed (handle);
+	if (ret != 1) {
+		fprintf (stderr, _("SELinux policy not managed\n"));
+		goto fail;
+	}
+
+	ret = semanage_access_check (handle);
+	if (ret < SEMANAGE_CAN_READ) {
+		fprintf (stderr, _("Cannot read SELinux policy store\n"));
+		goto fail;
+	}
+
+	ret = semanage_connect (handle);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Cannot establish SELinux management connection\n"));
+		goto fail;
+	}
+
+	ret = semanage_begin_transaction (handle);
+	if (ret != 0) {
+		fprintf (stderr, _("Cannot begin SELinux transaction\n"));
+		goto fail;
+	}
+
+	return handle;
+
+fail:
+	semanage_handle_destroy (handle);
+	return NULL;
+}
+
+
+static int semanage_user_mod (semanage_handle_t *handle,
+                              semanage_seuser_key_t *key,
+                              const char *login_name,
+                              const char *seuser_name)
+{
+	int ret;
+	semanage_seuser_t *seuser = NULL;
+
+	semanage_seuser_query (handle, key, &seuser);
+	if (NULL == seuser) {
+		fprintf (stderr,
+		         _("Could not query seuser for %s\n"), login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_set_mlsrange (handle, seuser, DEFAULT_SERANGE);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not set serange for %s\n"), login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_set_sename (handle, seuser, seuser_name);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not set sename for %s\n"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_modify_local (handle, key, seuser);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not modify login mapping for %s\n"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = 0;
+done:
+	semanage_seuser_free (seuser);
+	return ret;
+}
+
+
+static int semanage_user_add (semanage_handle_t *handle,
+                             semanage_seuser_key_t *key,
+                             const char *login_name,
+                             const char *seuser_name)
+{
+	int ret;
+	semanage_seuser_t *seuser = NULL;
+
+	ret = semanage_seuser_create (handle, &seuser);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Cannot create SELinux login mapping for %s\n"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_set_name (handle, seuser, login_name);
+	if (ret != 0) {
+		fprintf (stderr, _("Could not set name for %s\n"), login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_set_mlsrange (handle, seuser, DEFAULT_SERANGE);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not set serange for %s\n"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_set_sename (handle, seuser, seuser_name);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not set SELinux user for %s\n"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_modify_local (handle, key, seuser);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not add login mapping for %s\n"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = 0;
+done:
+	semanage_seuser_free (seuser);
+	return ret;
+}
+
+
+int set_seuser (const char *login_name, const char *seuser_name)
+{
+	semanage_handle_t *handle = NULL;
+	semanage_seuser_key_t *key = NULL;
+	int ret;
+	int seuser_exists = 0;
+
+	if (NULL == seuser_name) {
+		/* don't care, just let system pick the defaults */
+		return 0;
+	}
+
+	handle = semanage_init ();
+	if (NULL == handle) {
+		fprintf (stderr, _("Cannot init SELinux management\n"));
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_key_create (handle, login_name, &key);
+	if (ret != 0) {
+		fprintf (stderr, _("Cannot create SELinux user key\n"));
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_exists (handle, key, &seuser_exists);
+	if (ret < 0) {
+		fprintf (stderr, _("Cannot verify the SELinux user\n"));
+		ret = 1;
+		goto done;
+	}
+
+	if (0 != seuser_exists) {
+		ret = semanage_user_mod (handle, key, login_name, seuser_name);
+		if (ret != 0) {
+			fprintf (stderr,
+			         _("Cannot modify SELinux user mapping\n"));
+			ret = 1;
+			goto done;
+		}
+	} else {
+		ret = semanage_user_add (handle, key, login_name, seuser_name);
+		if (ret != 0) {
+			fprintf (stderr,
+			         _("Cannot add SELinux user mapping\n"));
+			ret = 1;
+			goto done;
+		}
+	}
+
+	ret = semanage_commit (handle);
+	if (ret < 0) {
+		fprintf (stderr, _("Cannot commit SELinux transaction\n"));
+		ret = 1;
+		goto done;
+	}
+
+	ret = 0;
+
+done:
+	semanage_seuser_key_free (key);
+	semanage_handle_destroy (handle);
+	return ret;
+}
+
+
+int del_seuser (const char *login_name)
+{
+	semanage_handle_t *handle = NULL;
+	semanage_seuser_key_t *key = NULL;
+	int ret;
+	int exists = 0;
+
+	handle = semanage_init ();
+	if (NULL == handle) {
+		fprintf (stderr, _("Cannot init SELinux management\n"));
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_key_create (handle, login_name, &key);
+	if (ret != 0) {
+		fprintf (stderr, _("Cannot create SELinux user key\n"));
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_seuser_exists (handle, key, &exists);
+	if (ret < 0) {
+		fprintf (stderr, _("Cannot verify the SELinux user\n"));
+		ret = 1;
+		goto done;
+	}
+
+	if (0 == exists) {
+		fprintf (stderr,
+		         _("Login mapping for %s is not defined, OK if default mapping was used\n"), 
+		         login_name);
+		ret = 0;  /* probably default mapping */
+		goto done;
+	}
+
+	ret = semanage_seuser_exists_local (handle, key, &exists);
+	if (ret < 0) {
+		fprintf (stderr, _("Cannot verify the SELinux user\n"));
+		ret = 1;
+		goto done;
+	}
+
+	if (0 == exists) {
+		fprintf (stderr,
+		         _("Login mapping for %s is defined in policy, cannot be deleted\n"), 
+		         login_name);
+		ret = 0; /* Login mapping defined in policy can't be deleted */
+		goto done;
+	}
+
+	ret = semanage_seuser_del_local (handle, key);
+	if (ret != 0) {
+		fprintf (stderr,
+		         _("Could not delete login mapping for %s"),
+		         login_name);
+		ret = 1;
+		goto done;
+	}
+
+	ret = semanage_commit (handle);
+	if (ret < 0) {
+		fprintf (stderr, _("Cannot commit SELinux transaction\n"));
+		ret = 1;
+		goto done;
+	}
+
+	ret = 0;
+done:
+	semanage_handle_destroy (handle);
+	return ret;
+}
+#else				/* !WITH_SELINUX */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* !WITH_SELINUX */
--- a/lib/sgetgrent.c
+++ b/lib/sgetgrent.c
@@ -35,6 +35,7 @@
 #ident "$Id$"

 #include <stdio.h>
+#include <sys/types.h>
 #include <grp.h>
 #include "defines.h"
 #include "prototypes.h"
@@ -87,10 +88,12 @@ static char **list (char *s)
 		if (!s || s[0] == '\0')
 			break;
 		members[i++] = s;
-		while (*s && *s != ',')
+		while (('\0' != *s) && (',' != *s)) {
 			s++;
-		if (*s)
+		}
+		if ('\0' != *s) {
 			*s++ = '\0';
+		}
 	}
 	members[i] = (char *) 0;
 	return members;
@@ -120,22 +123,32 @@ struct group *sgetgrent (const char *buf)
 	}
 	strcpy (grpbuf, buf);

-	if ((cp = strrchr (grpbuf, '\n')))
+	cp = strrchr (grpbuf, '\n');
+	if (NULL != cp) {
 		*cp = '\0';
-
-	for (cp = grpbuf, i = 0; i < NFIELDS && cp; i++) {
-		grpfields[i] = cp;
-		if ((cp = strchr (cp, ':')))
-			*cp++ = 0;
 	}
-	if (i < (NFIELDS - 1) || *grpfields[2] == '\0')
-		return 0;
+
+	for (cp = grpbuf, i = 0; (i < NFIELDS) && (NULL != cp); i++) {
+		grpfields[i] = cp;
+		cp = strchr (cp, ':');
+		if (NULL != cp) {
+			*cp = '\0';
+			cp++;
+		}
+	}
+	if (i < (NFIELDS - 1) || *grpfields[2] == '\0') {
+		return (struct group *) 0;
+	}
 	grent.gr_name = grpfields[0];
 	grent.gr_passwd = grpfields[1];
-	grent.gr_gid = atoi (grpfields[2]);
+	if (get_gid (grpfields[2], &grent.gr_gid) == 0) {
+		return (struct group *) 0;
+	}
 	grent.gr_mem = list (grpfields[3]);
-	if (!grent.gr_mem)
+	if (NULL == grent.gr_mem) {
 		return (struct group *) 0;	/* out of memory */
+	}

 	return &grent;
 }
+
--- a/lib/sgetpwent.c
+++ b/lib/sgetpwent.c
@@ -60,7 +60,6 @@ struct passwd *sgetpwent (const char *buf)
 	static char pwdbuf[1024];
 	register int i;
 	register char *cp;
-	char *ep;
 	char *fields[NFIELDS];

 	/*
@@ -77,15 +76,18 @@ struct passwd *sgetpwent (const char *buf)
 	 * field.  The fields are converted into NUL terminated strings.
 	 */

-	for (cp = pwdbuf, i = 0; i < NFIELDS && cp; i++) {
+	for (cp = pwdbuf, i = 0; (i < NFIELDS) && (NULL != cp); i++) {
 		fields[i] = cp;
-		while (*cp && *cp != ':')
-			++cp;
+		while (('\0' != *cp) && (':' != *cp)) {
+			cp++;
+		}

-		if (*cp)
-			*cp++ = '\0';
-		else
-			cp = 0;
+		if ('\0' != *cp) {
+			*cp = '\0';
+			cp++;
+		} else {
+			cp = NULL;
+		}
 	}

 	/*
@@ -94,7 +96,7 @@ struct passwd *sgetpwent (const char *buf)
 	 */

 	if (i != NFIELDS || *fields[2] == '\0' || *fields[3] == '\0')
-		return 0;
+		return NULL;

 	/*
 	 * Each of the fields is converted the appropriate data type
@@ -105,13 +107,11 @@ struct passwd *sgetpwent (const char *buf)

 	pwent.pw_name = fields[0];
 	pwent.pw_passwd = fields[1];
-	if (fields[2][0] == '\0' ||
-	    ((pwent.pw_uid = strtol (fields[2], &ep, 10)) == 0 && *ep)) {
-		return 0;
+	if (get_uid (fields[2], &pwent.pw_uid) == 0) {
+		return NULL;
 	}
-	if (fields[3][0] == '\0' ||
-	    ((pwent.pw_gid = strtol (fields[3], &ep, 10)) == 0 && *ep)) {
-		return 0;
+	if (get_gid (fields[3], &pwent.pw_gid) == 0) {
+		return NULL;
 	}
 	pwent.pw_gecos = fields[4];
 	pwent.pw_dir = fields[5];
@@ -119,3 +119,4 @@ struct passwd *sgetpwent (const char *buf)

 	return &pwent;
 }
+
--- a/lib/sgetspent.c
+++ b/lib/sgetspent.c
@@ -2,6 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2009       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -31,6 +32,9 @@

 #include <config.h>

+/* Newer versions of Linux libc already have shadow support.  */
+#ifndef HAVE_SGETSPENT
+
 #ident "$Id$"

 #include <sys/types.h>
@@ -56,32 +60,41 @@ struct spwd *sgetspent (const char *string)
 	 * have to do that to our private copy.
 	 */

-	if (strlen (string) >= sizeof spwbuf)
+	if (strlen (string) >= sizeof spwbuf) {
 		return 0;	/* fail if too long */
+	}
 	strcpy (spwbuf, string);

-	if ((cp = strrchr (spwbuf, '\n')))
+	cp = strrchr (spwbuf, '\n');
+	if (NULL != cp) {
 		*cp = '\0';
+	}

 	/*
 	 * Tokenize the string into colon separated fields.  Allow up to
 	 * FIELDS different fields.
 	 */

-	for (cp = spwbuf, i = 0; *cp && i < FIELDS; i++) {
+	for (cp = spwbuf, i = 0; ('\0' != *cp) && (i < FIELDS); i++) {
 		fields[i] = cp;
-		while (*cp && *cp != ':')
+		while (('\0' != *cp) && (':' != *cp)) {
 			cp++;
+		}

-		if (*cp)
-			*cp++ = '\0';
+		if ('\0' != *cp) {
+			*cp = '\0';
+			cp++;
+		}
 	}

-	if (i == (FIELDS - 1))
+	if (i == (FIELDS - 1)) {
 		fields[i++] = cp;
+	}

-	if ((cp && *cp) || (i != FIELDS && i != OFIELDS))
+	if ( ((NULL != cp) && ('\0' != *cp)) ||
+	     ((i != FIELDS) && (i != OFIELDS)) ) {
 		return 0;
+	}

 	/*
 	 * Start populating the structure.  The fields are all in
@@ -97,28 +110,34 @@ struct spwd *sgetspent (const char *string)
 	 * incorrectly formatted number.
 	 */

-	if ((spwd.sp_lstchg = strtol (fields[2], &cpp, 10)) == 0 && *cpp) {
-		return 0;
-	} else if (fields[2][0] == '\0')
+	if (fields[2][0] == '\0') {
 		spwd.sp_lstchg = -1;
+	} else if (   (getlong (fields[2], &spwd.sp_lstchg) == 0)
+	           || (spwd.sp_lstchg < 0)) {
+		return 0;
+	}

 	/*
 	 * Get the minimum period between password changes.
 	 */

-	if ((spwd.sp_min = strtol (fields[3], &cpp, 10)) == 0 && *cpp) {
-		return 0;
-	} else if (fields[3][0] == '\0')
+	if (fields[3][0] == '\0') {
 		spwd.sp_min = -1;
+	} else if (   (getlong (fields[3], &spwd.sp_min) == 0)
+	           || (spwd.sp_min < 0)) {
+		return 0;
+	}

 	/*
 	 * Get the maximum number of days a password is valid.
 	 */

-	if ((spwd.sp_max = strtol (fields[4], &cpp, 10)) == 0 && *cpp) {
-		return 0;
-	} else if (fields[4][0] == '\0')
+	if (fields[4][0] == '\0') {
 		spwd.sp_max = -1;
+	} else if (   (getlong (fields[4], &spwd.sp_max) == 0)
+	           || (spwd.sp_max < 0)) {
+		return 0;
+	}

 	/*
 	 * If there are only OFIELDS fields (this is a SVR3.2 /etc/shadow
@@ -126,8 +145,10 @@ struct spwd *sgetspent (const char *string)
 	 */

 	if (i == OFIELDS) {
-		spwd.sp_warn = spwd.sp_inact = spwd.sp_expire =
-		    spwd.sp_flag = -1;
+		spwd.sp_warn   = -1;
+		spwd.sp_inact  = -1;
+		spwd.sp_expire = -1;
+		spwd.sp_flag   = SHADOW_SP_FLAG_UNSET;

 		return &spwd;
 	}
@@ -136,40 +157,52 @@ struct spwd *sgetspent (const char *string)
 	 * Get the number of days of password expiry warning.
 	 */

-	if ((spwd.sp_warn = strtol (fields[5], &cpp, 10)) == 0 && *cpp) {
-		return 0;
-	} else if (fields[5][0] == '\0')
+	if (fields[5][0] == '\0') {
 		spwd.sp_warn = -1;
+	} else if (   (getlong (fields[5], &spwd.sp_warn) == 0)
+	           || (spwd.sp_warn < 0)) {
+		return 0;
+	}

 	/*
 	 * Get the number of days of inactivity before an account is
 	 * disabled.
 	 */

-	if ((spwd.sp_inact = strtol (fields[6], &cpp, 10)) == 0 && *cpp) {
-		return 0;
-	} else if (fields[6][0] == '\0')
+	if (fields[6][0] == '\0') {
 		spwd.sp_inact = -1;
+	} else if (   (getlong (fields[6], &spwd.sp_inact) == 0)
+	           || (spwd.sp_inact < 0)) {
+		return 0;
+	}

 	/*
 	 * Get the number of days after the epoch before the account is
 	 * set to expire.
 	 */

-	if ((spwd.sp_expire = strtol (fields[7], &cpp, 10)) == 0 && *cpp) {
-		return 0;
-	} else if (fields[7][0] == '\0')
+	if (fields[7][0] == '\0') {
 		spwd.sp_expire = -1;
+	} else if (   (getlong (fields[7], &spwd.sp_expire) == 0)
+	           || (spwd.sp_expire < 0)) {
+		return 0;
+	}

 	/*
 	 * This field is reserved for future use.  But it isn't supposed
 	 * to have anything other than a valid integer in it.
 	 */

-	if ((spwd.sp_flag = strtol (fields[8], &cpp, 10)) == 0 && *cpp) {
+	if (fields[8][0] == '\0') {
+		spwd.sp_flag = SHADOW_SP_FLAG_UNSET;
+	} else if (getlong (fields[8], &spwd.sp_flag) == 0) {
+		/* FIXME: add a getulong function */
 		return 0;
-	} else if (fields[8][0] == '\0')
-		spwd.sp_flag = -1;
+	}

 	return (&spwd);
 }
+#else
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif
+
--- a/lib/sgroupio.c
+++ b/lib/sgroupio.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2013, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -42,66 +42,126 @@
 #include "commonio.h"
 #include "sgroupio.h"

-struct sgrp *__sgr_dup (const struct sgrp *sgent)
+/*@null@*/ /*@only@*/struct sgrp *__sgr_dup (const struct sgrp *sgent)
 {
 	struct sgrp *sg;
 	int i;

-	if (!(sg = (struct sgrp *) malloc (sizeof *sg)))
+	sg = (struct sgrp *) malloc (sizeof *sg);
+	if (NULL == sg) {
 		return NULL;
-	*sg = *sgent;
-	if (!(sg->sg_name = strdup (sgent->sg_name)))
+	}
+	/* Do the same as the other _dup function, even if we know the
+	 * structure. */
+	memset (sg, 0, sizeof *sg);
+	/*@-mustfreeonly@*/
+	sg->sg_name = strdup (sgent->sg_name);
+	/*@=mustfreeonly@*/
+	if (NULL == sg->sg_name) {
+		free (sg);
 		return NULL;
-	if (!(sg->sg_passwd = strdup (sgent->sg_passwd)))
+	}
+	/*@-mustfreeonly@*/
+	sg->sg_passwd = strdup (sgent->sg_passwd);
+	/*@=mustfreeonly@*/
+	if (NULL == sg->sg_passwd) {
+		free (sg->sg_name);
+		free (sg);
 		return NULL;
+	}

-	for (i = 0; sgent->sg_adm[i]; i++);
+	for (i = 0; NULL != sgent->sg_adm[i]; i++);
+	/*@-mustfreeonly@*/
 	sg->sg_adm = (char **) malloc ((i + 1) * sizeof (char *));
-	if (!sg->sg_adm)
+	/*@=mustfreeonly@*/
+	if (NULL == sg->sg_adm) {
+		free (sg->sg_passwd);
+		free (sg->sg_name);
+		free (sg);
 		return NULL;
-	for (i = 0; sgent->sg_adm[i]; i++) {
+	}
+	for (i = 0; NULL != sgent->sg_adm[i]; i++) {
 		sg->sg_adm[i] = strdup (sgent->sg_adm[i]);
-		if (!sg->sg_adm[i])
+		if (NULL == sg->sg_adm[i]) {
+			for (i = 0; NULL != sg->sg_adm[i]; i++) {
+				free (sg->sg_adm[i]);
+			}
+			free (sg->sg_adm);
+			free (sg->sg_passwd);
+			free (sg->sg_name);
+			free (sg);
 			return NULL;
+		}
 	}
 	sg->sg_adm[i] = NULL;

-	for (i = 0; sgent->sg_mem[i]; i++);
+	for (i = 0; NULL != sgent->sg_mem[i]; i++);
+	/*@-mustfreeonly@*/
 	sg->sg_mem = (char **) malloc ((i + 1) * sizeof (char *));
-	if (!sg->sg_mem)
+	/*@=mustfreeonly@*/
+	if (NULL == sg->sg_mem) {
+		for (i = 0; NULL != sg->sg_adm[i]; i++) {
+			free (sg->sg_adm[i]);
+		}
+		free (sg->sg_adm);
+		free (sg->sg_passwd);
+		free (sg->sg_name);
+		free (sg);
 		return NULL;
-	for (i = 0; sgent->sg_mem[i]; i++) {
+	}
+	for (i = 0; NULL != sgent->sg_mem[i]; i++) {
 		sg->sg_mem[i] = strdup (sgent->sg_mem[i]);
-		if (!sg->sg_mem[i])
+		if (NULL == sg->sg_mem[i]) {
+			for (i = 0; NULL != sg->sg_mem[i]; i++) {
+				free (sg->sg_mem[i]);
+			}
+			free (sg->sg_mem);
+			for (i = 0; NULL != sg->sg_adm[i]; i++) {
+				free (sg->sg_adm[i]);
+			}
+			free (sg->sg_adm);
+			free (sg->sg_passwd);
+			free (sg->sg_name);
+			free (sg);
 			return NULL;
+		}
 	}
 	sg->sg_mem[i] = NULL;

 	return sg;
 }

-static void *gshadow_dup (const void *ent)
+static /*@null@*/ /*@only@*/void *gshadow_dup (const void *ent)
 {
 	const struct sgrp *sg = ent;

 	return __sgr_dup (sg);
 }

-static void gshadow_free (void *ent)
+static void gshadow_free (/*@out@*/ /*@only@*/void *ent)
 {
 	struct sgrp *sg = ent;

-	free (sg->sg_name);
-	free (sg->sg_passwd);
-	while (*(sg->sg_adm)) {
-		free (*(sg->sg_adm));
-		sg->sg_adm++;
+	sgr_free (sg);
+}
+
+void sgr_free (/*@out@*/ /*@only@*/struct sgrp *sgent)
+{
+	size_t i;
+	free (sgent->sg_name);
+	if (NULL != sgent->sg_passwd) {
+		memzero (sgent->sg_passwd, strlen (sgent->sg_passwd));
+		free (sgent->sg_passwd);
 	}
-	while (*(sg->sg_mem)) {
-		free (*(sg->sg_mem));
-		sg->sg_mem++;
+	for (i = 0; NULL != sgent->sg_adm[i]; i++) {
+		free (sgent->sg_adm[i]);
 	}
-	free (sg);
+	free (sgent->sg_adm);
+	for (i = 0; NULL != sgent->sg_mem[i]; i++) {
+		free (sgent->sg_mem[i]);
+	}
+	free (sgent->sg_mem);
+	free (sgent);
 }

 static const char *gshadow_getname (const void *ent)
@@ -120,6 +180,32 @@ static int gshadow_put (const void *ent, FILE * file)
 {
 	const struct sgrp *sg = ent;

+	if (   (NULL == sg)
+	    || (valid_field (sg->sg_name, ":\n") == -1)
+	    || (valid_field (sg->sg_passwd, ":\n") == -1)) {
+		return -1;
+	}
+
+	/* FIXME: fail also if sg->sg_adm == NULL ?*/
+	if (NULL != sg->sg_adm) {
+		size_t i;
+		for (i = 0; NULL != sg->sg_adm[i]; i++) {
+			if (valid_field (sg->sg_adm[i], ",:\n") == -1) {
+				return -1;
+			}
+		}
+	}
+
+	/* FIXME: fail also if sg->sg_mem == NULL ?*/
+	if (NULL != sg->sg_mem) {
+		size_t i;
+		for (i = 0; NULL != sg->sg_mem[i]; i++) {
+			if (valid_field (sg->sg_mem[i], ",:\n") == -1) {
+				return -1;
+			}
+		}
+	}
+
 	return (putsgent (sg, file) == -1) ? -1 : 0;
 }

@@ -145,18 +231,23 @@ static struct commonio_db gshadow_db = {
 	NULL,			/* head */
 	NULL,			/* tail */
 	NULL,			/* cursor */
-	0,			/* changed */
-	0,			/* isopen */
-	0,			/* locked */
-	0			/* readonly */
+	false,			/* changed */
+	false,			/* isopen */
+	false,			/* locked */
+	false			/* readonly */
 };

-int sgr_name (const char *filename)
+int sgr_setdbname (const char *filename)
 {
 	return commonio_setname (&gshadow_db, filename);
 }

-int sgr_file_present (void)
+/*@observer@*/const char *sgr_dbname (void)
+{
+	return gshadow_db.filename;
+}
+
+bool sgr_file_present (void)
 {
 	return commonio_present (&gshadow_db);
 }
@@ -171,7 +262,7 @@ int sgr_open (int mode)
 	return commonio_open (&gshadow_db, mode);
 }

-const struct sgrp *sgr_locate (const char *name)
+/*@observer@*/ /*@null@*/const struct sgrp *sgr_locate (const char *name)
 {
 	return commonio_locate (&gshadow_db, name);
 }
@@ -191,7 +282,7 @@ int sgr_rewind (void)
 	return commonio_rewind (&gshadow_db);
 }

-const struct sgrp *sgr_next (void)
+/*@null@*/const struct sgrp *sgr_next (void)
 {
 	return commonio_next (&gshadow_db);
 }
@@ -208,10 +299,10 @@ int sgr_unlock (void)

 void __sgr_set_changed (void)
 {
-	gshadow_db.changed = 1;
+	gshadow_db.changed = true;
 }

-struct commonio_entry *__sgr_get_head (void)
+/*@dependent@*/ /*@null@*/struct commonio_entry *__sgr_get_head (void)
 {
 	return gshadow_db.head;
 }
--- a/lib/sgroupio.h
+++ b/lib/sgroupio.h
@@ -31,16 +31,22 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

+/* $Id$ */
+#ifndef _SGROUPIO_H
+#define _SGROUPIO_H
+
 extern int sgr_close (void);
-extern int sgr_file_present (void);
-extern const struct sgrp *sgr_locate (const char *);
+extern bool sgr_file_present (void);
+extern /*@observer@*/ /*@null@*/const struct sgrp *sgr_locate (const char *name);
 extern int sgr_lock (void);
-extern int sgr_name (const char *);
-extern const struct sgrp *sgr_next (void);
-extern int sgr_open (int);
-extern int sgr_remove (const char *);
+extern int sgr_setdbname (const char *filename);
+extern /*@observer@*/const char *sgr_dbname (void);
+extern /*@null@*/const struct sgrp *sgr_next (void);
+extern int sgr_open (int mode);
+extern int sgr_remove (const char *name);
 extern int sgr_rewind (void);
 extern int sgr_unlock (void);
-extern int sgr_update (const struct sgrp *);
+extern int sgr_update (const struct sgrp *sg);
 extern int sgr_sort (void);

+#endif
--- a/lib/shadow.c
+++ b/lib/shadow.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2008       , Nicolas François
+ * Copyright (c) 2009       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -42,10 +42,10 @@
 #include "defines.h"
 #include <stdio.h>
 #ifdef	USE_NIS
-static int nis_used;
-static int nis_ignore;
+static bool nis_used;
+static bool nis_ignore;
 static enum { native, start, middle, native2 } nis_state;
-static int nis_bound;
+static bool nis_bound;
 static char *nis_domain;
 static char *nis_key;
 static int nis_keylen;
@@ -56,8 +56,6 @@ static int nis_vallen;
 #endif

 static FILE *shadow;
-static char spwbuf[BUFSIZ];
-static struct spwd spwd;

 #define	FIELDS	9
 #define	OFIELDS	5
@@ -68,12 +66,13 @@ static struct spwd spwd;
 * __setspNIS - turn on or off NIS searches
 */

-void __setspNIS (int flag)
+void __setspNIS (bool flag)
 {
 	nis_ignore = !flag;

-	if (nis_ignore)
-		nis_used = 0;
+	if (nis_ignore) {
+		nis_used = false;
+	}
 }

 /*
@@ -82,10 +81,11 @@ void __setspNIS (int flag)

 static int bind_nis (void)
 {
-	if (yp_get_default_domain (&nis_domain))
+	if (yp_get_default_domain (&nis_domain)) {
 		return -1;
+	}

-	nis_bound = 1;
+	nis_bound = true;
 	return 0;
 }
 #endif
@@ -96,10 +96,11 @@ static int bind_nis (void)

 void setspent (void)
 {
-	if (shadow)
+	if (NULL != shadow) {
 		rewind (shadow);
-	else
+	}else {
 		shadow = fopen (SHADOW_FILE, "r");
+	}

 #ifdef	USE_NIS
 	nis_state = native;
@@ -112,8 +113,9 @@ void setspent (void)

 void endspent (void)
 {
-	if (shadow)
+	if (NULL != shadow) {
 		(void) fclose (shadow);
+	}

 	shadow = (FILE *) 0;
 }
@@ -124,6 +126,8 @@ void endspent (void)

 static struct spwd *my_sgetspent (const char *string)
 {
+	static char spwbuf[BUFSIZ];
+	static struct spwd spwd;
 	char *fields[FIELDS];
 	char *cp;
 	char *cpp;
@@ -171,8 +175,9 @@ static struct spwd *my_sgetspent (const char *string)

 	spwd.sp_namp = fields[0];
 #ifdef	USE_NIS
-	if (IS_NISCHAR (fields[0][0]))
-		nis_used = 1;
+	if (IS_NISCHAR (fields[0][0])) {
+		nis_used = true;
+	}
 #endif
 	spwd.sp_pwdp = fields[1];

@@ -182,52 +187,60 @@ static struct spwd *my_sgetspent (const char *string)
 	 * incorrectly formatted number, unless we are using NIS.
 	 */

-	spwd.sp_lstchg = strtol (fields[2], &cpp, 10);
-	if ((spwd.sp_lstchg == 0) && *cpp) {
-#ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_lstchg = -1;
-#else
-		return 0;
-#endif
-	} else if (fields[2][0] == '\0')
+	if (fields[2][0] == '\0') {
 		spwd.sp_lstchg = -1;
+	} else {
+		if (getlong (fields[2], &spwd.sp_lstchg) == 0) {
+#ifdef	USE_NIS
+			if (nis_used) {
+				spwd.sp_lstchg = -1;
+			} else
+#endif
+				return 0;
+		} else if (spwd.sp_lstchg < 0) {
+			return 0;
+		}
+	}

 	/*
 	 * Get the minimum period between password changes.
 	 */

-	spwd.sp_min = strtol (fields[3], &cpp, 10);
-	if ((spwd.sp_min == 0) && *cpp) {
-#ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_min = -1;
-#else
-		return 0;
-#endif
-	} else if (fields[3][0] == '\0')
+	if (fields[3][0] == '\0') {
 		spwd.sp_min = -1;
+	} else {
+		if (getlong (fields[3], &spwd.sp_min) == 0) {
+#ifdef	USE_NIS
+			if (nis_used) {
+				spwd.sp_min = -1;
+			} else
+#endif
+			{
+				return 0;
+			}
+		} else if (spwd.sp_min < 0) {
+			return 0;
+		}
+	}

 	/*
 	 * Get the maximum number of days a password is valid.
 	 */

-	spwd.sp_max = strtol (fields[4], &cpp, 10);
-	if ((spwd.sp_max == 0) && *cpp) {
-#ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_max = -1;
-#else
-		return 0;
-#endif
-	} else if (fields[4][0] == '\0')
+	if (fields[4][0] == '\0') {
 		spwd.sp_max = -1;
+	} else {
+		if (getlong (fields[4], &spwd.sp_max) == 0) {
+#ifdef	USE_NIS
+			if (nis_used) {
+				spwd.sp_max = -1;
+			} else
+#endif
+				return 0;
+		} else if (spwd.sp_max < 0) {
+			return 0;
+		}
+	}

 	/*
 	 * If there are only OFIELDS fields (this is a SVR3.2 /etc/shadow
@@ -235,8 +248,10 @@ static struct spwd *my_sgetspent (const char *string)
 	 */

 	if (i == OFIELDS) {
-		spwd.sp_warn = spwd.sp_inact = spwd.sp_expire =
-		    spwd.sp_flag = -1;
+		spwd.sp_warn   = -1;
+		spwd.sp_inact  = -1;
+		spwd.sp_expire = -1;
+		spwd.sp_flag   = SHADOW_SP_FLAG_UNSET;

 		return &spwd;
 	}
@@ -245,72 +260,89 @@ static struct spwd *my_sgetspent (const char *string)
 	 * Get the number of days of password expiry warning.
 	 */

-	spwd.sp_warn = strtol (fields[5], &cpp, 10);
-	if ((spwd.sp_warn == 0) && *cpp) {
-#ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_warn = -1;
-#else
-		return 0;
-#endif
-	} else if (fields[5][0] == '\0')
+	if (fields[5][0] == '\0') {
 		spwd.sp_warn = -1;
+	} else {
+		if (getlong (fields[5], &spwd.sp_warn) == 0) {
+#ifdef	USE_NIS
+			if (nis_used) {
+				spwd.sp_warn = -1;
+			} else
+#endif
+			{
+				return 0;
+			}
+		} else if (spwd.sp_warn < 0) {
+			return 0;
+		}
+	}

 	/*
 	 * Get the number of days of inactivity before an account is
 	 * disabled.
 	 */

-	spwd.sp_inact = strtol (fields[6], &cpp, 10);
-	if ((spwd.sp_inact == 0) && *cpp) {
-#ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_inact = -1;
-#else
-		return 0;
-#endif
-	} else if (fields[6][0] == '\0')
+	if (fields[6][0] == '\0') {
 		spwd.sp_inact = -1;
+	} else {
+		if (getlong (fields[6], &spwd.sp_inact) == 0) {
+#ifdef	USE_NIS
+			if (nis_used) {
+				spwd.sp_inact = -1;
+			} else
+#endif
+			{
+				return 0;
+			}
+		} else if (spwd.sp_inact < 0) {
+			return 0;
+		}
+	}

 	/*
 	 * Get the number of days after the epoch before the account is
 	 * set to expire.
 	 */

-	spwd.sp_expire = strtol (fields[7], &cpp, 10);
-	if ((spwd.sp_expire == 0) && *cpp) {
-#ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_expire = -1;
-#else
-		return 0;
-#endif
-	} else if (fields[7][0] == '\0')
+	if (fields[7][0] == '\0') {
 		spwd.sp_expire = -1;
+	} else {
+		if (getlong (fields[7], &spwd.sp_expire) == 0) {
+#ifdef	USE_NIS
+			if (nis_used) {
+				spwd.sp_expire = -1;
+			} else
+#endif
+			{
+				return 0;
+			}
+		} else if (spwd.sp_expire < 0) {
+			return 0;
+		}
+	}

 	/*
 	 * This field is reserved for future use.  But it isn't supposed
 	 * to have anything other than a valid integer in it.
 	 */

-	spwd.sp_flag = strtol (fields[8], &cpp, 10);
-	if ((spwd.sp_flag == 0) && *cpp) {
+	if (fields[8][0] == '\0') {
+		spwd.sp_flag = SHADOW_SP_FLAG_UNSET;
+	} else {
+		if (getlong (fields[8], &spwd.sp_flag) == 0) {
+			/* FIXME: add a getulong function */
 #ifdef	USE_NIS
-		if (!nis_used)
-			return 0;
-		else
-			spwd.sp_flag = -1;
-#else
-		return 0;
+			if (nis_used) {
+				spwd.sp_flag = SHADOW_SP_FLAG_UNSET;
+			} else
 #endif
-	} else if (fields[8][0] == '\0')
-		spwd.sp_flag = -1;
+			{
+				return 0;
+			}
+		} else if (spwd.sp_flag < 0) {
+			return 0;
+		}
+	}

 	return (&spwd);
 }
@@ -324,21 +356,24 @@ struct spwd *fgetspent (FILE * fp)
 	char buf[BUFSIZ];
 	char *cp;

-	if (!fp)
+	if (NULL == fp) {
 		return (0);
+	}

 #ifdef	USE_NIS
-	while (fgets (buf, sizeof buf, fp) != (char *) 0)
+	while (fgets (buf, (int) sizeof buf, fp) != (char *) 0)
 #else
-	if (fgets (buf, sizeof buf, fp) != (char *) 0)
+	if (fgets (buf, (int) sizeof buf, fp) != (char *) 0)
 #endif
 	{
 		cp = strchr (buf, '\n');
-		if (NULL != cp)
+		if (NULL != cp) {
 			*cp = '\0';
+		}
 #ifdef	USE_NIS
-		if (nis_ignore && IS_NISCHAR (buf[0]))
+		if (nis_ignore && IS_NISCHAR (buf[0])) {
 			continue;
+		}
 #endif
 		return my_sgetspent (buf);
 	}
@@ -356,8 +391,9 @@ struct spwd *getspent (void)
 	struct spwd *val;
 	char buf[BUFSIZ];
 #endif
-	if (!shadow)
+	if (NULL == shadow) {
 		setspent ();
+	}

 #ifdef	USE_NIS
      again:
@@ -411,7 +447,7 @@ struct spwd *getspent (void)

 		return 0;
 	} else {
-		if (nis_bound == 0) {
+		if (!nis_bound) {
 			if (bind_nis ()) {
 				nis_state = native2;
 				goto again;
@@ -419,15 +455,15 @@ struct spwd *getspent (void)
 		}
 		if (nis_state == start) {
 			if (yp_first (nis_domain, "shadow.bynam", &nis_key,
-				      &nis_keylen, &nis_val, &nis_vallen)) {
+			              &nis_keylen, &nis_val, &nis_vallen)) {
 				nis_state = native2;
 				goto again;
 			}
 			nis_state = middle;
 		} else if (nis_state == middle) {
 			if (yp_next (nis_domain, "shadow.bynam", nis_key,
-				     nis_keylen, &nis_key, &nis_keylen,
-				     &nis_val, &nis_vallen)) {
+			             nis_keylen, &nis_key, &nis_keylen,
+			             &nis_val, &nis_vallen)) {
 				nis_state = native2;
 				goto again;
 			}
@@ -450,7 +486,7 @@ struct spwd *getspnam (const char *name)
 #ifdef	USE_NIS
 	char buf[BUFSIZ];
 	static char save_name[16];
-	int nis_disabled = 0;
+	bool nis_disabled = false;
 #endif

 	setspent ();
@@ -460,18 +496,20 @@ struct spwd *getspnam (const char *name)
 	 * Search the shadow.byname map for this user.
 	 */

-	if (!nis_ignore && !nis_bound)
+	if (!nis_ignore && !nis_bound) {
 		bind_nis ();
+	}

 	if (!nis_ignore && nis_bound) {
 		char *cp;

 		if (yp_match (nis_domain, "shadow.byname", name,
-			      strlen (name), &nis_val, &nis_vallen) == 0) {
+		              strlen (name), &nis_val, &nis_vallen) == 0) {

 			cp = strchr (nis_val, '\n');
-			if (NULL != cp)
+			if (NULL != cp) {
 				*cp = '\0';
+			}

 			nis_state = middle;
 			sp = my_sgetspent (nis_val);
@@ -482,8 +520,9 @@ struct spwd *getspnam (const char *name)
 			}
 			endspent ();
 			return sp;
-		} else
+		} else {
 			nis_state = native2;
+		}
 	}
 #endif
 #ifdef	USE_NIS
@@ -495,17 +534,19 @@ struct spwd *getspnam (const char *name)
 	 */

 	if (nis_used) {
-		nis_ignore++;
-		nis_disabled++;
+		nis_ignore = true;
+		nis_disabled = true;
 	}
 #endif
 	while ((sp = getspent ()) != (struct spwd *) 0) {
-		if (strcmp (name, sp->sp_namp) == 0)
+		if (strcmp (name, sp->sp_namp) == 0) {
 			break;
+		}
 	}
 #ifdef	USE_NIS
-	if (nis_disabled)
-		nis_ignore--;
+	if (nis_disabled) {
+		nis_ignore = false;
+	}
 #endif
 	endspent ();
 	return (sp);
@@ -513,3 +554,4 @@ struct spwd *getspnam (const char *name)
 #else
 extern int errno;		/* warning: ANSI C forbids an empty source file */
 #endif
+
--- a/lib/shadowio.c
+++ b/lib/shadowio.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -41,21 +41,23 @@
 #include <stdio.h>
 #include "commonio.h"
 #include "shadowio.h"
+#ifdef WITH_TCB
+#include <tcb.h>
+#include "tcbfuncs.h"
+#endif				/* WITH_TCB */

-static void *shadow_dup (const void *ent)
+static /*@null@*/ /*@only@*/void *shadow_dup (const void *ent)
 {
 	const struct spwd *sp = ent;

 	return __spw_dup (sp);
 }

-static void shadow_free (void *ent)
+static void shadow_free (/*@out@*//*@only@*/void *ent)
 {
 	struct spwd *sp = ent;

-	free (sp->sp_namp);
-	free (sp->sp_pwdp);
-	free (sp);
+	spw_free (sp);
 }

 static const char *shadow_getname (const void *ent)
@@ -74,6 +76,12 @@ static int shadow_put (const void *ent, FILE * file)
 {
 	const struct spwd *sp = ent;

+	if (   (NULL == sp)
+	    || (valid_field (sp->sp_namp, ":\n") == -1)
+	    || (valid_field (sp->sp_pwdp, ":\n") == -1)) {
+		return -1;
+	}
+
 	return (putspent (sp, file) == -1) ? -1 : 0;
 }

@@ -95,37 +103,75 @@ static struct commonio_db shadow_db = {
 	NULL,			/* fp */
 #ifdef WITH_SELINUX
 	NULL,			/* scontext */
-#endif
+#endif				/* WITH_SELINUX */
 	NULL,			/* head */
 	NULL,			/* tail */
 	NULL,			/* cursor */
-	0,			/* changed */
-	0,			/* isopen */
-	0,			/* locked */
-	0			/* readonly */
+	false,			/* changed */
+	false,			/* isopen */
+	false,			/* locked */
+	false			/* readonly */
 };

-int spw_name (const char *filename)
+int spw_setdbname (const char *filename)
 {
 	return commonio_setname (&shadow_db, filename);
 }

-int spw_file_present (void)
+/*@observer@*/const char *spw_dbname (void)
+{
+	return shadow_db.filename;
+}
+
+bool spw_file_present (void)
 {
 	return commonio_present (&shadow_db);
 }

 int spw_lock (void)
 {
-	return commonio_lock (&shadow_db);
+#ifdef WITH_TCB
+	int retval = 0;
+
+	if (!getdef_bool ("USE_TCB")) {
+#endif				/* WITH_TCB */
+		return commonio_lock (&shadow_db);
+#ifdef WITH_TCB
+	}
+	if (shadowtcb_drop_priv () == SHADOWTCB_FAILURE) {
+		return 0;
+	}
+	if (lckpwdf_tcb (shadow_db.filename) == 0) {
+		shadow_db.locked = 1;
+		retval = 1;
+	}
+	if (shadowtcb_gain_priv () == SHADOWTCB_FAILURE) {
+		return 0;
+	}
+	return retval;
+#endif				/* WITH_TCB */
 }

 int spw_open (int mode)
 {
-	return commonio_open (&shadow_db, mode);
+	int retval = 0;
+#ifdef WITH_TCB
+	bool use_tcb = getdef_bool ("USE_TCB");
+
+	if (use_tcb && (shadowtcb_drop_priv () == SHADOWTCB_FAILURE)) {
+		return 0;
+	}
+#endif				/* WITH_TCB */
+	retval = commonio_open (&shadow_db, mode);
+#ifdef WITH_TCB
+	if (use_tcb && (shadowtcb_gain_priv () == SHADOWTCB_FAILURE)) {
+		return 0;
+	}
+#endif				/* WITH_TCB */
+	return retval;
 }

-const struct spwd *spw_locate (const char *name)
+/*@observer@*/ /*@null@*/const struct spwd *spw_locate (const char *name)
 {
 	return commonio_locate (&shadow_db, name);
 }
@@ -145,19 +191,52 @@ int spw_rewind (void)
 	return commonio_rewind (&shadow_db);
 }

-const struct spwd *spw_next (void)
+/*@observer@*/ /*@null@*/const struct spwd *spw_next (void)
 {
 	return commonio_next (&shadow_db);
 }

 int spw_close (void)
 {
-	return commonio_close (&shadow_db);
+	int retval = 0;
+#ifdef WITH_TCB
+	bool use_tcb = getdef_bool ("USE_TCB");
+
+	if (use_tcb && (shadowtcb_drop_priv () == SHADOWTCB_FAILURE)) {
+		return 0;
+	}
+#endif				/* WITH_TCB */
+	retval = commonio_close (&shadow_db);
+#ifdef WITH_TCB
+	if (use_tcb && (shadowtcb_gain_priv () == SHADOWTCB_FAILURE)) {
+		return 0;
+	}
+#endif				/* WITH_TCB */
+	return retval;
 }

 int spw_unlock (void)
 {
-	return commonio_unlock (&shadow_db);
+#ifdef WITH_TCB
+	int retval = 0;
+
+	if (!getdef_bool ("USE_TCB")) {
+#endif				/* WITH_TCB */
+		return commonio_unlock (&shadow_db);
+#ifdef WITH_TCB
+	}
+	if (shadowtcb_drop_priv () == SHADOWTCB_FAILURE) {
+		return 0;
+	}
+	if (ulckpwdf_tcb () == 0) {
+		shadow_db.locked = 0;
+		retval = 1;
+	}
+	if (shadowtcb_gain_priv () == SHADOWTCB_FAILURE) {
+		return 0;
+	}
+	return retval;
+#endif				/* WITH_TCB */
 }

 struct commonio_entry *__spw_get_head (void)
@@ -173,5 +252,10 @@ void __spw_del_entry (const struct commonio_entry *ent)
 /* Sort with respect to passwd ordering. */
 int spw_sort ()
 {
+#ifdef WITH_TCB
+	if (getdef_bool ("USE_TCB")) {
+		return 0;
+	}
+#endif				/* WITH_TCB */
 	return commonio_sort_wrt (&shadow_db, __pw_get_db ());
 }
--- a/lib/shadowio.h
+++ b/lib/shadowio.h
@@ -30,16 +30,24 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

+/* $Id$ */
+#ifndef _SHADOWIO_H
+#define _SHADOWIO_H
+
+#include "defines.h"
+
 extern int spw_close (void);
-extern int spw_file_present (void);
-extern const struct spwd *spw_locate (const char *);
+extern bool spw_file_present (void);
+extern /*@observer@*/ /*@null@*/const struct spwd *spw_locate (const char *name);
 extern int spw_lock (void);
-extern int spw_name (const char *);
-extern const struct spwd *spw_next (void);
-extern int spw_open (int);
-extern int spw_remove (const char *);
+extern int spw_setdbname (const char *filename);
+extern /*@observer@*/const char *spw_dbname (void);
+extern /*@observer@*/ /*@null@*/const struct spwd *spw_next (void);
+extern int spw_open (int mode);
+extern int spw_remove (const char *name);
 extern int spw_rewind (void);
 extern int spw_unlock (void);
-extern int spw_update (const struct spwd *);
+extern int spw_update (const struct spwd *sp);
 extern int spw_sort (void);

+#endif
--- a/lib/shadowmem.c
+++ b/lib/shadowmem.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2001       , Michał Moskal
 * Copyright (c) 2005       , Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2013, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -41,17 +41,49 @@
 #include <stdio.h>
 #include "shadowio.h"

-struct spwd *__spw_dup (const struct spwd *spent)
+/*@null@*/ /*@only@*/struct spwd *__spw_dup (const struct spwd *spent)
 {
 	struct spwd *sp;

-	if (!(sp = (struct spwd *) malloc (sizeof *sp)))
+	sp = (struct spwd *) malloc (sizeof *sp);
+	if (NULL == sp) {
 		return NULL;
-	*sp = *spent;
-	if (!(sp->sp_namp = strdup (spent->sp_namp)))
+	}
+	/* The libc might define other fields. They won't be copied. */
+	memset (sp, 0, sizeof *sp);
+	sp->sp_lstchg = spent->sp_lstchg;
+	sp->sp_min    = spent->sp_min;
+	sp->sp_max    = spent->sp_max;
+	sp->sp_warn   = spent->sp_warn;
+	sp->sp_inact  = spent->sp_inact;
+	sp->sp_expire = spent->sp_expire;
+	sp->sp_flag   = spent->sp_flag;
+	/*@-mustfreeonly@*/
+	sp->sp_namp   = strdup (spent->sp_namp);
+	/*@=mustfreeonly@*/
+	if (NULL == sp->sp_namp) {
+		free(sp);
 		return NULL;
-	if (!(sp->sp_pwdp = strdup (spent->sp_pwdp)))
+	}
+	/*@-mustfreeonly@*/
+	sp->sp_pwdp = strdup (spent->sp_pwdp);
+	/*@=mustfreeonly@*/
+	if (NULL == sp->sp_pwdp) {
+		free(sp->sp_namp);
+		free(sp);
 		return NULL;
+	}
+
 	return sp;
 }

+void spw_free (/*@out@*/ /*@only@*/struct spwd *spent)
+{
+	free (spent->sp_namp);
+	if (NULL != spent->sp_pwdp) {
+		memzero (spent->sp_pwdp, strlen (spent->sp_pwdp));
+		free (spent->sp_pwdp);
+	}
+	free (spent);
+}
+
--- a/lib/spawn.c
+++ b/lib/spawn.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2011       , Jonathan Nieder
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include "exitcodes.h"
+#include "prototypes.h"
+
+int run_command (const char *cmd, const char *argv[],
+                 /*@null@*/const char *envp[], /*@out@*/int *status)
+{
+	pid_t pid, wpid;
+
+	if (NULL == envp) {
+		envp = (const char **)environ;
+	}
+
+	(void) fflush (stdout);
+	(void) fflush (stderr);
+
+	pid = fork ();
+	if (0 == pid) {
+		(void) execve (cmd, (char * const *) argv,
+		               (char * const *) envp);
+		if (ENOENT == errno) {
+			exit (E_CMD_NOTFOUND);
+		}
+		fprintf (stderr, "%s: cannot execute %s: %s\n",
+		         Prog, cmd, strerror (errno));
+		exit (E_CMD_NOEXEC);
+	} else if ((pid_t)-1 == pid) {
+		fprintf (stderr, "%s: cannot execute %s: %s\n",
+		         Prog, cmd, strerror (errno));
+		return -1;
+	}
+
+	do {
+		wpid = waitpid (pid, status, 0);
+	} while (   ((pid_t)-1 == wpid && errno == EINTR)
+	         || (wpid != pid));
+
+	if ((pid_t)-1 == wpid) {
+		fprintf (stderr, "%s: waitpid (status: %d): %s\n",
+		         Prog, *status, strerror (errno));
+		return -1;
+	}
+
+	return 0;
+}
+
--- a/lib/subordinateio.c
+++ b/lib/subordinateio.c
@@ -0,0 +1,614 @@
+/*
+ * Copyright (c) 2012 - Eric Biederman
+ */
+
+#include <config.h>
+
+#ifdef ENABLE_SUBIDS
+
+#include "prototypes.h"
+#include "defines.h"
+#include <stdio.h>
+#include "commonio.h"
+#include "subordinateio.h"
+
+struct subordinate_range {
+	const char *owner;
+	unsigned long start;
+	unsigned long count;
+};
+
+#define NFIELDS 3
+
+/*
+ * subordinate_dup: create a duplicate range
+ *
+ * @ent: a pointer to a subordinate_range struct
+ *
+ * Returns a pointer to a newly allocated duplicate subordinate_range struct
+ * or NULL on failure
+ */
+static /*@null@*/ /*@only@*/void *subordinate_dup (const void *ent)
+{
+	const struct subordinate_range *rangeent = ent;
+	struct subordinate_range *range;
+
+	range = (struct subordinate_range *) malloc (sizeof *range);
+	if (NULL == range) {
+		return NULL;
+	}
+	range->owner = strdup (rangeent->owner);
+	if (NULL == range->owner) {
+		free(range);
+		return NULL;
+	}
+	range->start = rangeent->start;
+	range->count = rangeent->count;
+
+	return range;
+}
+
+/*
+ * subordinate_free: free a subordinate_range struct
+ *
+ * @ent: pointer to a subordinate_range struct to free.
+ */
+static void subordinate_free (/*@out@*/ /*@only@*/void *ent)
+{
+	struct subordinate_range *rangeent = ent;
+	
+	free ((void *)(rangeent->owner));
+	free (rangeent);
+}
+
+/*
+ * subordinate_parse:
+ *
+ * @line: a line to parse
+ *
+ * Returns a pointer to a subordinate_range struct representing the values
+ * in @line, or NULL on failure.  Note that the returned value should not
+ * be freed by the caller.
+ */
+static void *subordinate_parse (const char *line)
+{
+	static struct subordinate_range range;
+	static char rangebuf[1024];
+	int i;
+	char *cp;
+	char *fields[NFIELDS];
+
+	/*
+	 * Copy the string to a temporary buffer so the substrings can
+	 * be modified to be NULL terminated.
+	 */
+	if (strlen (line) >= sizeof rangebuf)
+		return NULL;	/* fail if too long */
+	strcpy (rangebuf, line);
+
+	/*
+	 * Save a pointer to the start of each colon separated
+	 * field.  The fields are converted into NUL terminated strings.
+	 */
+
+	for (cp = rangebuf, i = 0; (i < NFIELDS) && (NULL != cp); i++) {
+		fields[i] = cp;
+		while (('\0' != *cp) && (':' != *cp)) {
+			cp++;
+		}
+
+		if ('\0' != *cp) {
+			*cp = '\0';
+			cp++;
+		} else {
+			cp = NULL;
+		}
+	}
+
+	/*
+	 * There must be exactly NFIELDS colon separated fields or
+	 * the entry is invalid.  Also, fields must be non-blank.
+	 */
+	if (i != NFIELDS || *fields[0] == '\0' || *fields[1] == '\0' || *fields[2] == '\0')
+		return NULL;
+	range.owner = fields[0];
+	if (getulong (fields[1], &range.start) == 0)
+		return NULL;
+	if (getulong (fields[2], &range.count) == 0)
+		return NULL;
+
+	return &range;
+}
+
+/*
+ * subordinate_put: print a subordinate_range value to a file
+ *
+ * @ent: a pointer to a subordinate_range struct to print out.
+ * @file: file to which to print.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+static int subordinate_put (const void *ent, FILE * file)
+{
+	const struct subordinate_range *range = ent;
+
+	return fprintf(file, "%s:%lu:%lu\n",
+			       range->owner,
+			       range->start,
+			       range->count) < 0 ? -1  : 0;
+}
+
+static struct commonio_ops subordinate_ops = {
+	subordinate_dup,	/* dup */
+	subordinate_free,	/* free */
+	NULL,			/* getname */
+	subordinate_parse,	/* parse */
+	subordinate_put,	/* put */
+	fgets,			/* fgets */
+	fputs,			/* fputs */
+	NULL,			/* open_hook */
+	NULL,			/* close_hook */
+};
+
+static /*@observer@*/ /*@null*/const struct subordinate_range *subordinate_next(struct commonio_db *db)
+{
+	return (const struct subordinate_range *)commonio_next (db);
+}
+
+/*
+ * range_exists: Check whether @owner owns any ranges
+ *
+ * @db: database to query
+ * @owner: owner being queried
+ *
+ * Returns true if @owner owns any subuid ranges, false otherwise.
+ */
+static const bool range_exists(struct commonio_db *db, const char *owner)
+{
+	const struct subordinate_range *range;
+	commonio_rewind(db);
+	while ((range = commonio_next(db)) != NULL) {
+		if (0 == strcmp(range->owner, owner))
+			return true;
+	}
+	return false;
+}
+
+/*
+ * find_range: find a range which @owner is authorized to use which includes
+ *             subuid @val.
+ *
+ * @db: database to query
+ * @owner: owning uid being queuried
+ * @val: subuid being searched for.
+ *
+ * Returns a range of subuids belonging to @owner and including the subuid
+ * @val, or NULL if no such range exists.
+ */
+static const struct subordinate_range *find_range(struct commonio_db *db,
+						  const char *owner, unsigned long val)
+{
+	const struct subordinate_range *range;
+	commonio_rewind(db);
+	while ((range = commonio_next(db)) != NULL) {
+		unsigned long first = range->start;
+		unsigned long last = first + range->count - 1;
+
+		if (0 != strcmp(range->owner, owner))
+			continue;
+
+		if ((val >= first) && (val <= last))
+			return range;
+	}
+	return NULL;
+}
+
+/*
+ * have_range: check whether @owner is authorized to use the range
+ *             (@start .. @start+@count-1).
+ * @db: database to check
+ * @owner: owning uid being queried
+ * @start: start of range
+ * @count: number of uids in range
+ *
+ * Returns true if @owner is authorized to use the range, false otherwise.
+ */
+static bool have_range(struct commonio_db *db,
+		       const char *owner, unsigned long start, unsigned long count)
+{
+	const struct subordinate_range *range;
+	unsigned long end;
+
+	if (count == 0)
+		return false;
+
+	end = start + count - 1;
+	range = find_range (db, owner, start);
+	while (range) {
+		unsigned long last; 
+
+		last = range->start + range->count - 1;
+		if (last >= (start + count - 1))
+			return true;
+
+		count = end - last;
+		start = last + 1;
+		range = find_range(db, owner, start);
+	}
+	return false;
+}
+
+/*
+ * subordinate_range_cmp: compare uid ranges
+ *
+ * @p1: pointer to a commonio_entry struct to compare
+ * @p2: pointer to second commonio_entry struct to compare
+ *
+ * Returns 0 if the entries are the same.  Otherwise return -1
+ * if the range in p1 is lower than that in p2, or (if the ranges are
+ * equal) if the owning uid in p1 is lower than p2's.  Return 1 if p1's
+ * range or owning uid is great than p2's.
+ */
+static int subordinate_range_cmp (const void *p1, const void *p2)
+{
+	struct subordinate_range *range1, *range2;
+
+	if ((*(struct commonio_entry **) p1)->eptr == NULL)
+		return 1;
+	if ((*(struct commonio_entry **) p2)->eptr == NULL)
+		return -1;
+
+	range1 = ((struct subordinate_range *) (*(struct commonio_entry **) p1)->eptr);
+	range2 = ((struct subordinate_range *) (*(struct commonio_entry **) p2)->eptr);
+
+	if (range1->start < range2->start)
+		return -1;
+	else if (range1->start > range2->start)
+		return 1;
+	else if (range1->count < range2->count)
+		return -1;
+	else if (range1->count > range2->count)
+		return 1;
+	else
+		return strcmp(range1->owner, range2->owner);
+}
+
+/*
+ * find_free_range: find an unused consecutive sequence of ids to allocate
+ *                  to a user.
+ * @db: database to search
+ * @min: the first uid in the range to find
+ * @max: the highest uid to find
+ * @count: the number of uids needed
+ *
+ * Return the lowest new uid, or ULONG_MAX on failure.
+ */
+static unsigned long find_free_range(struct commonio_db *db,
+				     unsigned long min, unsigned long max,
+				     unsigned long count)
+{
+	const struct subordinate_range *range;
+	unsigned long low, high;
+
+	/* When given invalid parameters fail */
+	if ((count == 0) || (max < min))
+		goto fail;
+
+	/* Sort by range then by owner */
+	commonio_sort (db, subordinate_range_cmp);
+	commonio_rewind(db);
+
+	low = min;
+	while ((range = commonio_next(db)) != NULL) {
+		unsigned long first = range->start;
+		unsigned long last = first + range->count - 1;
+
+		/* Find the top end of the hole before this range */
+		high = first;
+
+		/* Don't allocate IDs after max (included) */
+		if (high > max + 1) {
+			high = max + 1;
+		}
+
+		/* Is the hole before this range large enough? */
+		if ((high > low) && ((high - low) >= count))
+			return low;
+
+		/* Compute the low end of the next hole */
+		if (low < (last + 1))
+			low = last + 1;
+		if (low > max)
+			goto fail;
+	}
+
+	/* Is the remaining unclaimed area large enough? */
+	if (((max - low) + 1) >= count)
+		return low;
+fail:
+	return ULONG_MAX;
+}
+
+/*
+ * add_range: add a subuid range to an owning uid's list of authorized
+ *            subuids.
+ * @db: database to which to add
+ * @owner: uid which owns the subuid
+ * @start: the first uid in the owned range
+ * @count: the number of uids in the range
+ *
+ * Return 1 if the range is already present or on succcess.  On error
+ * return 0 and set errno appropriately.
+ */
+static int add_range(struct commonio_db *db,
+	const char *owner, unsigned long start, unsigned long count)
+{
+	struct subordinate_range range;
+	range.owner = owner;
+	range.start = start;
+	range.count = count;
+
+	/* See if the range is already present */
+	if (have_range(db, owner, start, count))
+		return 1;
+
+	/* Otherwise append the range */
+	return commonio_append(db, &range);
+}
+
+/*
+ * remove_range:  remove a range of subuids from an owning uid's list
+ *                of authorized subuids.
+ * @db: database to work on
+ * @owner: owning uid whose range is being removed
+ * @start: start of the range to be removed
+ * @count: number of uids in the range.
+ *
+ * Returns 0 on failure, 1 on success.  Failure means that we needed to
+ * create a new range to represent the new limits, and failed doing so.
+ */
+static int remove_range (struct commonio_db *db,
+                         const char *owner,
+                         unsigned long start, unsigned long count)
+{
+	struct commonio_entry *ent;
+	unsigned long end;
+
+	if (count == 0) {
+		return 1;
+	}
+
+	end = start + count - 1;
+	for (ent = db->head; NULL != ent; ent = ent->next) {
+		struct subordinate_range *range = ent->eptr;
+		unsigned long first;
+		unsigned long last;
+
+		/* Skip unparsed entries */
+		if (NULL == range) {
+			continue;
+		}
+
+		first = range->start;
+		last = first + range->count - 1;
+
+		/* Skip entries with a different owner */
+		if (0 != strcmp (range->owner, owner)) {
+			continue;
+		}
+
+		/* Skip entries outside of the range to remove */
+		if ((end < first) || (start > last)) {
+			continue;
+		}
+
+		if (start <= first) {
+			if (end >= last) {
+				/* to be removed: [start,      end]
+				 * range:           [first, last] */
+				/* entry completely contained in the
+				 * range to remove */
+				commonio_del_entry (db, ent);
+			} else {
+				/* to be removed: [start,  end]
+				 * range:           [first, last] */
+				/* Remove only the start of the entry */
+				range->start = end + 1;
+				range->count = (last - range->start) + 1;
+
+				ent->changed = true;
+				db->changed = true;
+			}
+		} else {
+			if (end >= last) {
+				/* to be removed:   [start,  end]
+				 * range:         [first, last] */
+				/* Remove only the end of the entry */
+				range->count = start - range->start;
+
+				ent->changed = true;
+				db->changed = true;
+			} else {
+				/* to be removed:   [start, end]
+				 * range:         [first,    last] */
+				/* Remove the middle of the range
+				 * This requires to create a new range */
+				struct subordinate_range tail;
+				tail.owner = range->owner;
+				tail.start = end + 1;
+				tail.count = (last - tail.start) + 1;
+
+				if (commonio_append (db, &tail) == 0) {
+					return 0;
+				}
+
+				range->count = start - range->start;
+
+				ent->changed = true;
+				db->changed = true;
+			}
+		}
+	}
+
+	return 1;
+}
+
+static struct commonio_db subordinate_uid_db = {
+	"/etc/subuid",		/* filename */
+	&subordinate_ops,	/* ops */
+	NULL,			/* fp */
+#ifdef WITH_SELINUX
+	NULL,			/* scontext */
+#endif
+	NULL,			/* head */
+	NULL,			/* tail */
+	NULL,			/* cursor */
+	false,			/* changed */
+	false,			/* isopen */
+	false,			/* locked */
+	false			/* readonly */
+};
+
+int sub_uid_setdbname (const char *filename)
+{
+	return commonio_setname (&subordinate_uid_db, filename);
+}
+
+/*@observer@*/const char *sub_uid_dbname (void)
+{
+	return subordinate_uid_db.filename;
+}
+
+bool sub_uid_file_present (void)
+{
+	return commonio_present (&subordinate_uid_db);
+}
+
+int sub_uid_lock (void)
+{
+	return commonio_lock (&subordinate_uid_db);
+}
+
+int sub_uid_open (int mode)
+{
+	return commonio_open (&subordinate_uid_db, mode);
+}
+
+bool sub_uid_assigned(const char *owner)
+{
+	return range_exists (&subordinate_uid_db, owner);
+}
+
+bool have_sub_uids(const char *owner, uid_t start, unsigned long count)
+{
+	return have_range (&subordinate_uid_db, owner, start, count);
+}
+
+int sub_uid_add (const char *owner, uid_t start, unsigned long count)
+{
+	return add_range (&subordinate_uid_db, owner, start, count);
+}
+
+int sub_uid_remove (const char *owner, uid_t start, unsigned long count)
+{
+	return remove_range (&subordinate_uid_db, owner, start, count);
+}
+
+int sub_uid_close (void)
+{
+	return commonio_close (&subordinate_uid_db);
+}
+
+int sub_uid_unlock (void)
+{
+	return commonio_unlock (&subordinate_uid_db);
+}
+
+uid_t sub_uid_find_free_range(uid_t min, uid_t max, unsigned long count)
+{
+	unsigned long start;
+	start = find_free_range (&subordinate_uid_db, min, max, count);
+	return start == ULONG_MAX ? (uid_t) -1 : start;
+}
+
+static struct commonio_db subordinate_gid_db = {
+	"/etc/subgid",		/* filename */
+	&subordinate_ops,	/* ops */
+	NULL,			/* fp */
+#ifdef WITH_SELINUX
+	NULL,			/* scontext */
+#endif
+	NULL,			/* head */
+	NULL,			/* tail */
+	NULL,			/* cursor */
+	false,			/* changed */
+	false,			/* isopen */
+	false,			/* locked */
+	false			/* readonly */
+};
+
+int sub_gid_setdbname (const char *filename)
+{
+	return commonio_setname (&subordinate_gid_db, filename);
+}
+
+/*@observer@*/const char *sub_gid_dbname (void)
+{
+	return subordinate_gid_db.filename;
+}
+
+bool sub_gid_file_present (void)
+{
+	return commonio_present (&subordinate_gid_db);
+}
+
+int sub_gid_lock (void)
+{
+	return commonio_lock (&subordinate_gid_db);
+}
+
+int sub_gid_open (int mode)
+{
+	return commonio_open (&subordinate_gid_db, mode);
+}
+
+bool have_sub_gids(const char *owner, gid_t start, unsigned long count)
+{
+	return have_range(&subordinate_gid_db, owner, start, count);
+}
+
+bool sub_gid_assigned(const char *owner)
+{
+	return range_exists (&subordinate_gid_db, owner);
+}
+
+int sub_gid_add (const char *owner, gid_t start, unsigned long count)
+{
+	return add_range (&subordinate_gid_db, owner, start, count);
+}
+
+int sub_gid_remove (const char *owner, gid_t start, unsigned long count)
+{
+	return remove_range (&subordinate_gid_db, owner, start, count);
+}
+
+int sub_gid_close (void)
+{
+	return commonio_close (&subordinate_gid_db);
+}
+
+int sub_gid_unlock (void)
+{
+	return commonio_unlock (&subordinate_gid_db);
+}
+
+gid_t sub_gid_find_free_range(gid_t min, gid_t max, unsigned long count)
+{
+	unsigned long start;
+	start = find_free_range (&subordinate_gid_db, min, max, count);
+	return start == ULONG_MAX ? (gid_t) -1 : start;
+}
+#else				/* !ENABLE_SUBIDS */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* !ENABLE_SUBIDS */
+
--- a/lib/subordinateio.h
+++ b/lib/subordinateio.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2012- Eric W. Biederman
+ */
+
+#ifndef _SUBORDINATEIO_H
+#define _SUBORDINATEIO_H
+
+#include <config.h>
+
+#ifdef ENABLE_SUBIDS
+
+#include <sys/types.h>
+
+extern int sub_uid_close(void);
+extern bool have_sub_uids(const char *owner, uid_t start, unsigned long count);
+extern bool sub_uid_file_present (void);
+extern bool sub_uid_assigned(const char *owner);
+extern int sub_uid_lock (void);
+extern int sub_uid_setdbname (const char *filename);
+extern /*@observer@*/const char *sub_uid_dbname (void);
+extern int sub_uid_open (int mode);
+extern int sub_uid_unlock (void);
+extern int sub_uid_add (const char *owner, uid_t start, unsigned long count);
+extern int sub_uid_remove (const char *owner, uid_t start, unsigned long count);
+extern uid_t sub_uid_find_free_range(uid_t min, uid_t max, unsigned long count);
+
+extern int sub_gid_close(void);
+extern bool have_sub_gids(const char *owner, gid_t start, unsigned long count);
+extern bool sub_gid_file_present (void);
+extern bool sub_gid_assigned(const char *owner);
+extern int sub_gid_lock (void);
+extern int sub_gid_setdbname (const char *filename);
+extern /*@observer@*/const char *sub_gid_dbname (void);
+extern int sub_gid_open (int mode);
+extern int sub_gid_unlock (void);
+extern int sub_gid_add (const char *owner, gid_t start, unsigned long count);
+extern int sub_gid_remove (const char *owner, gid_t start, unsigned long count);
+extern uid_t sub_gid_find_free_range(gid_t min, gid_t max, unsigned long count);
+#endif				/* ENABLE_SUBIDS */
+
+#endif
--- a/lib/tcbfuncs.c
+++ b/lib/tcbfuncs.c
@@ -0,0 +1,613 @@
+/*
+ * Copyright (c) 2001 Rafal Wojtczuk, Solar Designer
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <grp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <tcb.h>
+#include <unistd.h>
+
+#include "config.h"
+
+#include "defines.h"
+#include "prototypes.h"
+#include "getdef.h"
+#include "shadowio.h"
+#include "tcbfuncs.h"
+
+#define SHADOWTCB_HASH_BY 1000
+#define SHADOWTCB_LOCK_SUFFIX ".lock"
+
+static /*@null@*//*@only@*/char *stored_tcb_user = NULL;
+
+shadowtcb_status shadowtcb_drop_priv (void)
+{
+	if (!getdef_bool ("USE_TCB")) {
+		return SHADOWTCB_SUCCESS;
+	}
+
+	if (NULL != stored_tcb_user) {
+		if (tcb_drop_priv (stored_tcb_user) == 0) {
+			return SHADOWTCB_SUCCESS;
+		}
+	}
+
+	return SHADOWTCB_FAILURE;
+}
+
+shadowtcb_status shadowtcb_gain_priv (void)
+{
+	if (!getdef_bool ("USE_TCB")) {
+		return SHADOWTCB_SUCCESS;
+	}
+
+	return (tcb_gain_priv () == 0) ? SHADOWTCB_SUCCESS : SHADOWTCB_FAILURE;
+}
+
+/* In case something goes wrong, we return immediately, not polluting the
+ * code with free(). All errors are fatal, so the application is expected
+ * to exit soon.
+ */
+#define OUT_OF_MEMORY do { \
+	fprintf (stderr, _("%s: out of memory\n"), Prog); \
+	(void) fflush (stderr); \
+} while (false)
+
+/* Returns user's tcb directory path relative to TCB_DIR. */
+static /*@null@*/ char *shadowtcb_path_rel (const char *name, uid_t uid)
+{
+	char *ret;
+
+	if (!getdef_bool ("TCB_SYMLINKS") || uid < SHADOWTCB_HASH_BY) {
+		if (asprintf (&ret, "%s", name) == -1) {
+			OUT_OF_MEMORY;
+			return NULL;
+		}
+	} else if (uid < SHADOWTCB_HASH_BY * SHADOWTCB_HASH_BY) {
+		if (asprintf (&ret, ":%dK/%s",
+		              uid / SHADOWTCB_HASH_BY, name) == -1) {
+			OUT_OF_MEMORY;
+			return NULL;
+		}
+	} else {
+		if (asprintf (&ret, ":%dM/:%dK/%s",
+		              uid / (SHADOWTCB_HASH_BY * SHADOWTCB_HASH_BY),
+		              (uid % (SHADOWTCB_HASH_BY * SHADOWTCB_HASH_BY)) / SHADOWTCB_HASH_BY,
+			name) == -1) {
+			OUT_OF_MEMORY;
+			return NULL;
+		}
+	}
+	return ret;
+}
+
+static /*@null@*/ char *shadowtcb_path_rel_existing (const char *name)
+{
+	char *path, *rval;
+	struct stat st;
+	char link[8192];
+	ssize_t ret;
+
+	if (asprintf (&path, TCB_DIR "/%s", name) == -1) {
+		OUT_OF_MEMORY;
+		return NULL;
+	}
+	if (lstat (path, &st) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot stat %s: %s\n"),
+		         Prog, path, strerror (errno));
+		free (path);
+		return NULL;
+	}
+	if (S_ISDIR (st.st_mode)) {
+		free (path);
+		rval = strdup (name);
+		if (NULL == rval) {
+			OUT_OF_MEMORY;
+			return NULL;
+		}
+		return rval;
+	}
+	if (!S_ISLNK (st.st_mode)) {
+		fprintf (stderr,
+		         _("%s: %s is neither a directory, nor a symlink.\n"),
+		         Prog, path);
+		free (path);
+		return NULL;
+	}
+	ret = readlink (path, link, sizeof (link) - 1);
+	if (-1 == ret) {
+		fprintf (stderr,
+		         _("%s: Cannot read symbolic link %s: %s\n"),
+		         Prog, path, strerror (errno));
+		free (path);
+		return NULL;
+	}
+	free (path);
+	if ((size_t)ret >= sizeof(link) - 1) {
+		link[sizeof(link) - 1] = '\0';
+		fprintf (stderr,
+		         _("%s: Suspiciously long symlink: %s\n"),
+		         Prog, link);
+		return NULL;
+	}
+	link[(size_t)ret] = '\0';
+	rval = strdup (link);
+	if (NULL == rval) {
+		OUT_OF_MEMORY;
+		return NULL;
+	}
+	return rval;
+}
+
+static /*@null@*/ char *shadowtcb_path (const char *name, uid_t uid)
+{
+	char *ret, *rel;
+
+	rel = shadowtcb_path_rel (name, uid);
+	if (NULL == rel) {
+		return NULL;
+	}
+	if (asprintf (&ret, TCB_DIR "/%s", rel) == -1) {
+		OUT_OF_MEMORY;
+		free (rel);
+		return NULL;
+	}
+	free (rel);
+	return ret;
+}
+
+static /*@null@*/ char *shadowtcb_path_existing (const char *name)
+{
+	char *ret, *rel;
+
+	rel = shadowtcb_path_rel_existing (name);
+	if (NULL == rel) {
+		return NULL;
+	}
+	if (asprintf (&ret, TCB_DIR "/%s", rel) == -1) {
+		OUT_OF_MEMORY;
+		free (rel);
+		return NULL;
+	}
+	free (rel);
+	return ret;
+}
+
+static shadowtcb_status mkdir_leading (const char *name, uid_t uid)
+{
+	char *ind, *dir, *ptr, *path = shadowtcb_path_rel (name, uid);
+	struct stat st;
+
+	if (NULL == path) {
+		return SHADOWTCB_FAILURE;
+	}
+	ptr = path;
+	if (stat (TCB_DIR, &st) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot stat %s: %s\n"),
+		         Prog, TCB_DIR, strerror (errno));
+		goto out_free_path;
+	}
+	while ((ind = strchr (ptr, '/'))) {
+		*ind = '\0';
+		if (asprintf (&dir, TCB_DIR "/%s", path) == -1) {
+			OUT_OF_MEMORY;
+			return SHADOWTCB_FAILURE;
+		}
+		if ((mkdir (dir, 0700) != 0) && (errno != EEXIST)) {
+			fprintf (stderr,
+			         _("%s: Cannot create directory %s: %s\n"),
+			         Prog, dir, strerror (errno));
+			goto out_free_dir;
+		}
+		if (chown (dir, 0, st.st_gid) != 0) {
+			fprintf (stderr,
+			         _("%s: Cannot change owner of %s: %s\n"),
+			         Prog, dir, strerror (errno));
+			goto out_free_dir;
+		}
+		if (chmod (dir, 0711) != 0) {
+			fprintf (stderr,
+			         _("%s: Cannot change mode of %s: %s\n"),
+			         Prog, dir, strerror (errno));
+			goto out_free_dir;
+		}
+		free (dir);
+		*ind = '/';
+		ptr = ind + 1;
+	}
+	free (path);
+	return SHADOWTCB_SUCCESS;
+out_free_dir:
+	free (dir);
+out_free_path:
+	free (path);
+	return SHADOWTCB_FAILURE;
+}
+
+static shadowtcb_status unlink_suffs (const char *user)
+{
+	static char *suffs[] = { "+", "-", SHADOWTCB_LOCK_SUFFIX };
+	char *tmp;
+	int i;
+
+	for (i = 0; i < 3; i++) {
+		if (asprintf (&tmp, TCB_FMT "%s", user, suffs[i]) == -1) {
+			OUT_OF_MEMORY;
+			return SHADOWTCB_FAILURE;
+		}
+		if ((unlink (tmp) != 0) && (errno != ENOENT)) {
+			fprintf (stderr,
+			         _("%s: unlink: %s: %s\n"),
+			         Prog, tmp, strerror (errno));
+			free (tmp);
+			return SHADOWTCB_FAILURE;
+		}
+		free (tmp);
+	}
+
+	return SHADOWTCB_SUCCESS;
+}
+
+/* path should be a relative existing tcb directory */
+static shadowtcb_status rmdir_leading (char *path)
+{
+	char *ind, *dir;
+	shadowtcb_status ret = SHADOWTCB_SUCCESS;
+	while ((ind = strrchr (path, '/'))) {
+		*ind = '\0';
+		if (asprintf (&dir, TCB_DIR "/%s", path) == -1) {
+			OUT_OF_MEMORY;
+			return SHADOWTCB_FAILURE;
+		}
+		if (rmdir (dir) != 0) {
+			if (errno != ENOTEMPTY) {
+				fprintf (stderr,
+				         _("%s: Cannot remove directory %s: %s\n"),
+				         Prog, dir, strerror (errno));
+				ret = SHADOWTCB_FAILURE;
+			}
+			free (dir);
+			break;
+		}
+		free (dir);
+	}
+	return ret;
+}
+
+static shadowtcb_status move_dir (const char *user_newname, uid_t user_newid)
+{
+	char *olddir = NULL, *newdir = NULL;
+	char *real_old_dir = NULL, *real_new_dir = NULL;
+	char *real_old_dir_rel = NULL, *real_new_dir_rel = NULL;
+	uid_t old_uid, the_newid;
+	struct stat oldmode;
+	shadowtcb_status ret = SHADOWTCB_FAILURE;
+
+	if (NULL == stored_tcb_user) {
+		return SHADOWTCB_FAILURE;
+	}
+	if (asprintf (&olddir, TCB_DIR "/%s", stored_tcb_user) == -1) {
+		goto out_free_nomem;
+	}
+	if (stat (olddir, &oldmode) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot stat %s: %s\n"),
+		         Prog, olddir, strerror (errno));
+		goto out_free;
+	}
+	old_uid = oldmode.st_uid;
+	the_newid = (user_newid == -1) ? old_uid : user_newid;
+	real_old_dir = shadowtcb_path_existing (stored_tcb_user);
+	if (NULL == real_old_dir) {
+		goto out_free;
+	}
+	real_new_dir = shadowtcb_path (user_newname, the_newid);
+	if (NULL == real_new_dir) {
+		goto out_free;
+	}
+	if (strcmp (real_old_dir, real_new_dir) == 0) {
+		ret = SHADOWTCB_SUCCESS;
+		goto out_free;
+	}
+	real_old_dir_rel = shadowtcb_path_rel_existing (stored_tcb_user);
+	if (NULL == real_old_dir_rel) {
+		goto out_free;
+	}
+	if (mkdir_leading (user_newname, the_newid) == SHADOWTCB_FAILURE) {
+		goto out_free;
+	}
+	if (rename (real_old_dir, real_new_dir) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot rename %s to %s: %s\n"),
+		         Prog, real_old_dir, real_new_dir, strerror (errno));
+		goto out_free;
+	}
+	if (rmdir_leading (real_old_dir_rel) == SHADOWTCB_FAILURE) {
+		goto out_free;
+	}
+	if ((unlink (olddir) != 0) && (errno != ENOENT)) {
+		fprintf (stderr,
+		         _("%s: Cannot remove %s: %s\n"),
+		         Prog, olddir, strerror (errno));
+		goto out_free;
+	}
+	if (asprintf (&newdir, TCB_DIR "/%s", user_newname) == -1) {
+		goto out_free_nomem;
+	}
+	real_new_dir_rel = shadowtcb_path_rel (user_newname, the_newid);
+	if (NULL == real_new_dir_rel) {
+		goto out_free;
+	}
+	if (   (strcmp (real_new_dir, newdir) != 0)
+	    && (symlink (real_new_dir_rel, newdir) != 0)) {
+		fprintf (stderr,
+		         _("%s: Cannot create symbolic link %s: %s\n"),
+		         Prog, real_new_dir_rel, strerror (errno));
+		goto out_free;
+	}
+	ret = SHADOWTCB_SUCCESS;
+	goto out_free;
+out_free_nomem:
+	OUT_OF_MEMORY;
+out_free:
+	free (olddir);
+	free (newdir);
+	free (real_old_dir);
+	free (real_new_dir);
+	free (real_old_dir_rel);
+	free (real_new_dir_rel);
+	return ret;
+}
+
+shadowtcb_status shadowtcb_set_user (const char* name)
+{
+	char *buf;
+	shadowtcb_status retval;
+
+	if (!getdef_bool ("USE_TCB")) {
+		return SHADOWTCB_SUCCESS;
+	}
+
+	if (NULL != stored_tcb_user) {
+		free (stored_tcb_user);
+	}
+
+	stored_tcb_user = strdup (name);
+	if (NULL == stored_tcb_user) {
+		OUT_OF_MEMORY;
+		return SHADOWTCB_FAILURE;
+	}
+	if (asprintf (&buf, TCB_FMT, name) == -1) {
+		OUT_OF_MEMORY;
+		return SHADOWTCB_FAILURE;
+	}
+
+	retval = (spw_setdbname (buf) != 0) ? SHADOWTCB_SUCCESS : SHADOWTCB_FAILURE;
+	free (buf);
+	return retval;
+}
+
+/* tcb directory must be empty before shadowtcb_remove is called. */
+shadowtcb_status shadowtcb_remove (const char *name)
+{
+	shadowtcb_status ret = SHADOWTCB_SUCCESS;
+	char *path = shadowtcb_path_existing (name);
+	char *rel = shadowtcb_path_rel_existing (name);
+	if ((NULL == path) || (NULL == rel) || (rmdir (path) != 0)) {
+		return SHADOWTCB_FAILURE;
+	}
+	if (rmdir_leading (rel) == SHADOWTCB_FAILURE) {
+		return SHADOWTCB_FAILURE;
+	}
+	free (path);
+	free (rel);
+	if (asprintf (&path, TCB_DIR "/%s", name) == -1) {
+		OUT_OF_MEMORY;
+		return SHADOWTCB_FAILURE;
+	}
+	if ((unlink (path) != 0) && (errno != ENOENT)) {
+		ret = SHADOWTCB_FAILURE;
+	}
+	free (path);
+	return ret;
+}
+
+shadowtcb_status shadowtcb_move (/*@NULL@*/const char *user_newname, uid_t user_newid)
+{
+	struct stat dirmode, filemode;
+	char *tcbdir, *shadow;
+	shadowtcb_status ret = SHADOWTCB_FAILURE;
+
+	if (!getdef_bool ("USE_TCB")) {
+		return SHADOWTCB_SUCCESS;
+	}
+	if (NULL == stored_tcb_user) {
+		return SHADOWTCB_FAILURE;
+	}
+	if (NULL == user_newname) {
+		user_newname = stored_tcb_user;
+	}
+	if (move_dir (user_newname, user_newid) == SHADOWTCB_FAILURE) {
+		return SHADOWTCB_FAILURE;
+	}
+	if (-1 == user_newid) {
+		return SHADOWTCB_SUCCESS;
+	}
+	if (   (asprintf (&tcbdir, TCB_DIR "/%s", user_newname) == -1)
+	    || (asprintf (&shadow, TCB_FMT, user_newname) == -1)) {
+		OUT_OF_MEMORY;
+		return SHADOWTCB_FAILURE;
+	}
+	if (stat (tcbdir, &dirmode) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot stat %s: %s\n"),
+		         Prog, tcbdir, strerror (errno));
+		goto out_free;
+	}
+	if (chown (tcbdir, 0, 0) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change owners of %s: %s\n"),
+		         Prog, tcbdir, strerror (errno));
+		goto out_free;
+	}
+	if (chmod (tcbdir, 0700) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change mode of %s: %s\n"),
+		         Prog, tcbdir, strerror (errno));
+		goto out_free;
+	}
+	if (lstat (shadow, &filemode) != 0) {
+		if (errno != ENOENT) {
+			fprintf (stderr,
+			         _("%s: Cannot lstat %s: %s\n"),
+			         Prog, shadow, strerror (errno));
+			goto out_free;
+		}
+		fprintf (stderr,
+		         _("%s: Warning, user %s has no tcb shadow file.\n"),
+		         Prog, user_newname);
+	} else {
+		if (!S_ISREG (filemode.st_mode) ||
+			filemode.st_nlink != 1) {
+			fprintf (stderr,
+			         _("%s: Emergency: %s's tcb shadow is not a "
+			           "regular file with st_nlink=1.\n"
+			           "The account is left locked.\n"),
+			         Prog, user_newname);
+			goto out_free;
+		}
+		if (chown (shadow, user_newid, filemode.st_gid) != 0) {
+			fprintf (stderr,
+			         _("%s: Cannot change owner of %s: %s\n"),
+			         Prog, shadow, strerror (errno));
+			goto out_free;
+		}
+		if (chmod (shadow, filemode.st_mode & 07777) != 0) {
+			fprintf (stderr,
+			         _("%s: Cannot change mode of %s: %s\n"),
+			         Prog, shadow, strerror (errno));
+			goto out_free;
+		}
+	}
+	if (unlink_suffs (user_newname) == SHADOWTCB_FAILURE) {
+		goto out_free;
+	}
+	if (chown (tcbdir, user_newid, dirmode.st_gid) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change owner of %s: %s\n"),
+		         Prog, tcbdir, strerror (errno));
+		goto out_free;
+	}
+	ret = SHADOWTCB_SUCCESS;
+out_free:
+	free (tcbdir);
+	free (shadow);
+	return ret;
+}
+
+shadowtcb_status shadowtcb_create (const char *name, uid_t uid)
+{
+	char *dir, *shadow;
+	struct stat tcbdir_stat;
+	gid_t shadowgid, authgid;
+	struct group *gr;
+	int fd;
+	shadowtcb_status ret = SHADOWTCB_FAILURE;
+
+	if (!getdef_bool ("USE_TCB")) {
+		return SHADOWTCB_SUCCESS;
+	}
+	if (stat (TCB_DIR, &tcbdir_stat) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot stat %s: %s\n"),
+		         Prog, TCB_DIR, strerror (errno));
+		return SHADOWTCB_FAILURE;
+	}
+	shadowgid = tcbdir_stat.st_gid;
+	authgid = shadowgid;
+	if (getdef_bool ("TCB_AUTH_GROUP")) {
+		gr = getgrnam ("auth");
+		if (NULL != gr) {
+			authgid = gr->gr_gid;
+		}
+	}
+
+	if (   (asprintf (&dir, TCB_DIR "/%s", name) == -1)
+	    || (asprintf (&shadow, TCB_FMT, name) == -1)) {
+		OUT_OF_MEMORY;
+		return SHADOWTCB_FAILURE;
+	}
+	if (mkdir (dir, 0700) != 0) {
+		fprintf (stderr,
+		         _("%s: mkdir: %s: %s\n"),
+		         Prog, dir, strerror (errno));
+		goto out_free;
+	}
+	fd = open (shadow, O_RDWR | O_CREAT | O_TRUNC, 0600);
+	if (fd < 0) {
+		fprintf (stderr,
+		         _("%s: Cannot open %s: %s\n"),
+		         Prog, shadow, strerror (errno));
+		goto out_free;
+	}
+	close (fd);
+	if (chown (shadow, 0, authgid) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change owner of %s: %s\n"),
+		         Prog, shadow, strerror (errno));
+		goto out_free;
+	}
+	if (chmod (shadow, (mode_t) ((authgid == shadowgid) ? 0600 : 0640)) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change mode of %s: %s\n"),
+		         Prog, shadow, strerror (errno));
+		goto out_free;
+	}
+	if (chown (dir, 0, authgid) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change owner of %s: %s\n"),
+		         Prog, dir, strerror (errno));
+		goto out_free;
+	}
+	if (chmod (dir, (mode_t) ((authgid == shadowgid) ? 02700 : 02710)) != 0) {
+		fprintf (stderr,
+		         _("%s: Cannot change mode of %s: %s\n"),
+		         Prog, dir, strerror (errno));
+		goto out_free;
+	}
+	if (   (shadowtcb_set_user (name) == SHADOWTCB_FAILURE)
+	    || (shadowtcb_move (NULL, uid) == SHADOWTCB_FAILURE)) {
+		goto out_free;
+	}
+	ret = SHADOWTCB_SUCCESS;
+out_free:
+	free (dir);
+	free (shadow);
+	return ret;
+}
+
--- a/lib/tcbfuncs.h
+++ b/lib/tcbfuncs.h
@@ -0,0 +1,19 @@
+#ifndef _TCBFUNCS_H
+#define _TCBFUNCS_H
+
+#include <sys/types.h>
+
+typedef enum {
+	SHADOWTCB_FAILURE = 0,
+	SHADOWTCB_SUCCESS = 1
+} shadowtcb_status;
+
+extern shadowtcb_status shadowtcb_drop_priv (void);
+extern shadowtcb_status shadowtcb_gain_priv (void);
+extern shadowtcb_status shadowtcb_set_user (const char *name);
+extern shadowtcb_status shadowtcb_remove (const char *name);
+extern shadowtcb_status shadowtcb_move (/*@null@*/const char *user_newname,
+                                        uid_t user_newid);
+extern shadowtcb_status shadowtcb_create (const char *name, uid_t uid);
+
+#endif
--- a/lib/utent.c
+++ b/lib/utent.c
@@ -88,25 +88,6 @@ struct utmp *getutent (void)

 	return &utmp_buf;
 }
-
-/*
- * getutline - get the utmp entry matching ut_line
- */
-
-struct utmp *getutline (const struct utmp *utent)
-{
-	struct utmp save;
-	struct utmp *new;
-
-	save = *utent;
-	while (new = getutent ())
-		if (strncmp (new->ut_line, save.ut_line, sizeof new->ut_line))
-			continue;
-		else
-			return new;
-
-	return (struct utmp *) 0;
-}
 #else
 extern int errno;		/* warning: ANSI C forbids an empty source file */
 #endif
--- a/libmisc/Makefile.am
+++ b/libmisc/Makefile.am
@@ -14,18 +14,26 @@ libmisc_a_SOURCES = \
 	chkname.h \
 	chowndir.c \
 	chowntty.c \
+	cleanup.c \
+	cleanup_group.c \
+	cleanup_user.c \
 	console.c \
 	copydir.c \
 	entry.c \
 	env.c \
 	failure.c \
 	failure.h \
-	fields.c \
-	find_new_ids.c \
+	find_new_gid.c \
+	find_new_uid.c \
+	find_new_sub_gids.c \
+	find_new_sub_uids.c \
 	getdate.h \
 	getdate.y \
-	getlong.c \
+	getgr_nam_gid.c \
+	getrange.c \
 	hushed.c \
+	idmapping.h \
+	idmapping.c \
 	isexpired.c \
 	limits.c \
 	list.c log.c \
@@ -35,10 +43,13 @@ libmisc_a_SOURCES = \
 	myname.c \
 	obscure.c \
 	pam_pass.c \
+	pam_pass_non_interractive.c \
 	pwd2spwd.c \
 	pwdcheck.c \
 	pwd_init.c \
+	remove_tree.c \
 	rlogin.c \
+	root_flag.c \
 	salt.c \
 	setugid.c \
 	setupenv.c \
@@ -49,6 +60,7 @@ libmisc_a_SOURCES = \
 	ttytype.c \
 	tz.c \
 	ulimit.c \
+	user_busy.c \
 	utmp.c \
 	valid.c \
 	xgetpwnam.c \
--- a/libmisc/addgrps.c
+++ b/libmisc/addgrps.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2001 - 2006, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -32,7 +32,7 @@

 #include <config.h>

-#ifdef HAVE_SETGROUPS
+#if defined (HAVE_SETGROUPS) && ! defined (USE_PAM)

 #include "prototypes.h"
 #include "defines.h"
@@ -52,7 +52,9 @@
 int add_groups (const char *list)
 {
 	GETGROUPS_T *grouplist, *tmp;
-	int i, ngroups, added;
+	size_t i;
+	int ngroups;
+	bool added;
 	char *token;
 	char buf[1024];

@@ -65,11 +67,17 @@ int add_groups (const char *list)
 	i = 16;
 	for (;;) {
 		grouplist = (gid_t *) malloc (i * sizeof (GETGROUPS_T));
-		if (!grouplist)
+		if (NULL == grouplist) {
 			return -1;
+		}
 		ngroups = getgroups (i, grouplist);
-		if (i > ngroups)
+		if (   (   (-1 == ngroups)
+		        && (EINVAL != errno))
+		    || (i > (size_t)ngroups)) {
+			/* Unexpected failure of getgroups or successful
+			 * reception of the groups */
 			break;
+		}
 		/* not enough room, so try allocating a larger buffer */
 		free (grouplist);
 		i *= 2;
@@ -79,40 +87,45 @@ int add_groups (const char *list)
 		return -1;
 	}

-	added = 0;
-	for (token = strtok (buf, SEP); token; token = strtok (NULL, SEP)) {
+	added = false;
+	for (token = strtok (buf, SEP); NULL != token; token = strtok (NULL, SEP)) {
 		struct group *grp;

 		grp = getgrnam (token); /* local, no need for xgetgrnam */
-		if (!grp) {
+		if (NULL == grp) {
 			fprintf (stderr, _("Warning: unknown group %s\n"),
 				 token);
 			continue;
 		}

-		for (i = 0; i < ngroups && grouplist[i] != grp->gr_gid; i++);
+		for (i = 0; i < (size_t)ngroups && grouplist[i] != grp->gr_gid; i++);

-		if (i < ngroups)
+		if (i < (size_t)ngroups) {
 			continue;
+		}

 		if (ngroups >= sysconf (_SC_NGROUPS_MAX)) {
 			fputs (_("Warning: too many groups\n"), stderr);
 			break;
 		}
-		tmp = (gid_t *) realloc (grouplist, (ngroups + 1) * sizeof (GETGROUPS_T));
-		if (!tmp) {
+		tmp = (gid_t *) realloc (grouplist, (size_t)(ngroups + 1) * sizeof (GETGROUPS_T));
+		if (NULL == tmp) {
 			free (grouplist);
 			return -1;
 		}
-		tmp[ngroups++] = grp->gr_gid;
+		tmp[ngroups] = grp->gr_gid;
+		ngroups++;
 		grouplist = tmp;
-		added++;
+		added = true;
 	}

-	if (added)
-		return setgroups (ngroups, grouplist);
+	if (added) {
+		return setgroups ((size_t)ngroups, grouplist);
+	}

 	return 0;
 }
-#endif
+#else				/* HAVE_SETGROUPS && !USE_PAM */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* HAVE_SETGROUPS && !USE_PAM */

--- a/libmisc/age.c
+++ b/libmisc/age.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2001 - 2006, Tomasz Kłoczko
- * Copyright (c) 2008       , Nicolas François
+ * Copyright (c) 2008 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -53,31 +53,33 @@
 *	expire() calls /bin/passwd to change the user's password
 *	if it has expired.
 */
-int expire (const struct passwd *pw, const struct spwd *sp)
+int expire (const struct passwd *pw, /*@null@*/const struct spwd *sp)
 {
 	int status;
-	int child;
-	int pid;
+	pid_t child;
+	pid_t pid;

-	if (!sp)
-		sp = pwd_to_spwd (pw);
+	if (NULL == sp) {
+		return 0;
+	}

 	/*
 	 * See if the user's password has expired, and if so
 	 * force them to change their password.
 	 */

-	switch (status = isexpired (pw, sp)) {
+	status = isexpired (pw, sp);
+	switch (status) {
 	case 0:
 		return 0;
 	case 1:
-		fputs (_("Your password has expired."), stdout);
+		(void) fputs (_("Your password has expired."), stdout);
 		break;
 	case 2:
-		fputs (_("Your password is inactive."), stdout);
+		(void) fputs (_("Your password is inactive."), stdout);
 		break;
 	case 3:
-		fputs (_("Your login has expired."), stdout);
+		(void) fputs (_("Your login has expired."), stdout);
 		break;
 	}

@@ -88,12 +90,12 @@ int expire (const struct passwd *pw, const struct spwd *sp)
 	 * change that password.
 	 */

-	if (status > 1 || sp->sp_max < sp->sp_min) {
-		puts (_("  Contact the system administrator."));
-		exit (1);
+	if ((status > 1) || (sp->sp_max < sp->sp_min)) {
+		(void) puts (_("  Contact the system administrator."));
+		exit (EXIT_FAILURE);
 	}
-	puts (_("  Choose a new password."));
-	fflush (stdout);
+	(void) puts (_("  Choose a new password."));
+	(void) fflush (stdout);

 	/*
 	 * Close all the files so that unauthorized access won't
@@ -115,7 +117,8 @@ int expire (const struct passwd *pw, const struct spwd *sp)
 	 * change their password before being able to use the account.
 	 */

-	if ((pid = fork ()) == 0) {
+	pid = fork ();
+	if (0 == pid) {
 		int err;

 		/*
@@ -123,24 +126,32 @@ int expire (const struct passwd *pw, const struct spwd *sp)
 		 * passwd to work just like it would had they executed
 		 * it from the command line while logged in.
 		 */
-		if (setup_uid_gid (pw, 0))
+#if defined(HAVE_INITGROUPS) && ! defined(USE_PAM)
+		if (setup_uid_gid (pw, false) != 0)
+#else
+		if (setup_uid_gid (pw) != 0)
+#endif
+		{
 			_exit (126);
+		}

-		execl (PASSWD_PROGRAM, PASSWD_PROGRAM, pw->pw_name, (char *) 0);
+		(void) execl (PASSWD_PROGRAM, PASSWD_PROGRAM, pw->pw_name, (char *) 0);
 		err = errno;
 		perror ("Can't execute " PASSWD_PROGRAM);
-		_exit (err == ENOENT ? E_CMD_NOTFOUND : E_CMD_NOEXEC);
-	} else if (pid == -1) {
+		_exit ((ENOENT == err) ? E_CMD_NOTFOUND : E_CMD_NOEXEC);
+	} else if ((pid_t) -1 == pid) {
 		perror ("fork");
-		exit (1);
+		exit (EXIT_FAILURE);
 	}
-	while ((child = wait (&status)) != pid && child != -1);

-	if (child == pid && status == 0)
+	while (((child = wait (&status)) != pid) && (child != (pid_t)-1));
+
+	if ((child == pid) && (0 == status)) {
 		return 1;
+	}

-	exit (1);
- /*NOTREACHED*/}
+	exit (EXIT_FAILURE);
+ /*@notreached@*/}

 /*
 * agecheck - see if warning is needed for password expiration
@@ -149,30 +160,42 @@ int expire (const struct passwd *pw, const struct spwd *sp)
 *	to expire and warns the user of the pending password expiration.
 */

-void agecheck (const struct passwd *pw, const struct spwd *sp)
+void agecheck (/*@null@*/const struct spwd *sp)
 {
-	long now = time ((long *) 0) / SCALE;
+	long now = (long) time ((time_t *) 0) / SCALE;
 	long remain;

-	if (!sp)
-		sp = pwd_to_spwd (pw);
+	if (NULL == sp) {
+		return;
+	}

 	/*
 	 * The last, max, and warn fields must be supported or the
 	 * warning period cannot be calculated.
 	 */

-	if (sp->sp_lstchg == -1 || sp->sp_max == -1 || sp->sp_warn == -1)
+	if (   (-1 == sp->sp_lstchg)
+	    || (-1 == sp->sp_max)
+	    || (-1 == sp->sp_warn)) {
 		return;
-	if ((remain = (sp->sp_lstchg + sp->sp_max) - now) <= sp->sp_warn) {
+	}
+
+	if (0 == sp->sp_lstchg) {
+		(void) puts (_("You must change your password."));
+		return;
+	}
+
+	remain = sp->sp_lstchg + sp->sp_max - now;
+	if (remain <= sp->sp_warn) {
 		remain /= DAY / SCALE;
-		if (remain > 1)
-			printf (_
-				("Your password will expire in %ld days.\n"),
-				remain);
-		else if (remain == 1)
-			puts (_("Your password will expire tomorrow."));
-		else if (remain == 0)
-			puts (_("Your password will expire today."));
+		if (remain > 1) {
+			(void) printf (_("Your password will expire in %ld days.\n"),
+			               remain);
+		} else if (1 == remain) {
+			(void) puts (_("Your password will expire tomorrow."));
+		} else if (remain == 0) {
+			(void) puts (_("Your password will expire today."));
+		}
 	}
 }
+
--- a/libmisc/audit_help.c
+++ b/libmisc/audit_help.c
@@ -53,11 +53,14 @@ void audit_help_open (void)
 	if (audit_fd < 0) {
 		/* You get these only when the kernel doesn't have
 		 * audit compiled in. */
-		if (errno == EINVAL || errno == EPROTONOSUPPORT ||
-		    errno == EAFNOSUPPORT)
+		if (   (errno == EINVAL)
+		    || (errno == EPROTONOSUPPORT)
+		    || (errno == EAFNOSUPPORT)) {
 			return;
-		fprintf (stderr, "Cannot open audit interface - aborting.\n");
-		exit (1);
+		}
+		(void) fputs (_("Cannot open audit interface - aborting.\n"),
+		              stderr);
+		exit (EXIT_FAILURE);
 	}
 }

@@ -72,16 +75,32 @@ void audit_help_open (void)
 * name - user's account or group name. If not available use NULL.
 * id  -  uid or gid that the operation is being performed on. This is used
 *	  only when user is NULL.
- * result - 1 is "success" and 0 is "failed"
 */
-void audit_logger (int type, const char *pgname, const char *op,
-		   const char *name, unsigned int id, int result)
+void audit_logger (int type, unused const char *pgname, const char *op,
+                   const char *name, unsigned int id,
+                   shadow_audit_result result)
 {
-	if (audit_fd < 0)
+	if (audit_fd < 0) {
 		return;
-	else
+	} else {
 		audit_log_acct_message (audit_fd, type, NULL, op, name, id,
-					NULL, NULL, NULL, result);
+		                        NULL, NULL, NULL, (int) result);
+	}
+}
+
+void audit_logger_message (const char *message, shadow_audit_result result)
+{
+	if (audit_fd < 0) {
+		return;
+	} else {
+		audit_log_user_message (audit_fd,
+		                        AUDIT_USYS_CONFIG,
+		                        message,
+		                        NULL, /* hostname */
+		                        NULL, /* addr */
+		                        NULL, /* tty */
+		                        (int) result);
+	}
 }

 #else				/* WITH_AUDIT */
--- a/libmisc/basename.c
+++ b/libmisc/basename.c
@@ -42,9 +42,9 @@

 #include "defines.h"
 #include "prototypes.h"
-char *Basename (char *str)
+/*@observer@*/const char *Basename (const char *str)
 {
 	char *cp = strrchr (str, '/');

-	return cp ? cp + 1 : str;
+	return (NULL != cp) ? cp + 1 : str;
 }
--- a/libmisc/chkname.c
+++ b/libmisc/chkname.c
@@ -31,8 +31,11 @@
 */

 /*
- * check_user_name(), check_group_name() - check the new user/group
- * name for validity; return value: 1 - OK, 0 - bad name
+ * is_valid_user_name(), is_valid_group_name() - check the new user/group
+ * name for validity;
+ * return values:
+ *   true  - OK
+ *   false - bad name
 */

 #include <config.h>
@@ -42,57 +45,55 @@
 #include <ctype.h>
 #include "defines.h"
 #include "chkname.h"
-#if HAVE_UTMPX_H
-#include <utmpx.h>
-#else
-#include <utmp.h>
-#endif
-static int good_name (const char *name)
+
+static bool is_valid_name (const char *name)
 {
 	/*
 	 * User/group names must match [a-z_][a-z0-9_-]*[$]
 	 */
-	if (!*name || !((*name >= 'a' && *name <= 'z') || *name == '_'))
-		return 0;
-
-	while (*++name) {
-		if (!((*name >= 'a' && *name <= 'z') ||
-		      (*name >= '0' && *name <= '9') ||
-		      *name == '_' || *name == '-' ||
-		      (*name == '$' && *(name + 1) == '\0')))
-			return 0;
+	if (('\0' == *name) ||
+	    !((('a' <= *name) && ('z' >= *name)) || ('_' == *name))) {
+		return false;
 	}

-	return 1;
+	while ('\0' != *++name) {
+		if (!(( ('a' <= *name) && ('z' >= *name) ) ||
+		      ( ('0' <= *name) && ('9' >= *name) ) ||
+		      ('_' == *name) ||
+		      ('-' == *name) ||
+		      ( ('$' == *name) && ('\0' == *(name + 1)) )
+		     )) {
+			return false;
+		}
+	}
+
+	return true;
 }

-int check_user_name (const char *name)
+bool is_valid_user_name (const char *name)
 {
-#if HAVE_UTMPX_H
-	struct utmpx ut;
-#else
-	struct utmp ut;
-#endif
-
 	/*
 	 * User names are limited by whatever utmp can
-	 * handle (usually max 8 characters).
+	 * handle.
 	 */
-	if (strlen (name) > sizeof (ut.ut_user))
-		return 0;
+	if (strlen (name) > USER_NAME_MAX_LENGTH) {
+		return false;
+	}

-	return good_name (name);
+	return is_valid_name (name);
 }

-int check_group_name (const char *name)
+bool is_valid_group_name (const char *name)
 {
 	/*
-	 * Arbitrary limit for group names - max 16
-	 * characters (same as on HP-UX 10).
+	 * Arbitrary limit for group names.
+	 * HP-UX 10 limits to 16 characters
 	 */
-	if (strlen (name) > 16)
-		return 0;
+	if (   (GROUP_NAME_MAX_LENGTH > 0)
+	    && (strlen (name) > GROUP_NAME_MAX_LENGTH)) {
+		return false;
+	}

-	return good_name (name);
+	return is_valid_name (name);
 }

--- a/libmisc/chkname.h
+++ b/libmisc/chkname.h
@@ -2,6 +2,7 @@
 * Copyright (c) 1990 - 1994, Julianne Frances Haugh
 * Copyright (c) 1997 - 2000, Marek Michałkiewicz
 * Copyright (c) 2005       , Tomasz Kłoczko
+ * Copyright (c) 2008       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,13 +35,16 @@
 #define _CHKNAME_H_

 /*
- * check_user_name(), check_group_name() - check the new user/group
- * name for validity; return value: 1 - OK, 0 - bad name
+ * is_valid_user_name(), is_valid_group_name() - check the new user/group
+ * name for validity;
+ * return values:
+ *   true  - OK
+ *   false - bad name
 */

 #include "defines.h"

-extern int check_user_name (const char *);
-extern int check_group_name (const char *name);
+extern bool is_valid_user_name (const char *name);
+extern bool is_valid_group_name (const char *name);

 #endif
--- a/libmisc/chowndir.c
+++ b/libmisc/chowndir.c
@@ -2,6 +2,7 @@
 * Copyright (c) 1992 - 1993, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2010 -     , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -44,59 +45,92 @@
 *
 *	chown_dir() walks a directory tree and changes the ownership
 *	of all files owned by the provided user ID.
+ *
+ *	Only files owned (resp. group-owned) by old_uid (resp. by old_gid)
+ *	will have their ownership (resp. group-ownership) modified, unless
+ *	old_uid (resp. old_gid) is set to -1.
+ *
+ *	new_uid and new_gid can be set to -1 to indicate that no owner or
+ *	group-owner shall be changed.
 */
-int
-chown_tree (const char *root, uid_t old_uid, uid_t new_uid, gid_t old_gid,
-	    gid_t new_gid)
+int chown_tree (const char *root,
+                uid_t old_uid,
+                uid_t new_uid,
+                gid_t old_gid,
+                gid_t new_gid)
 {
-	char new_name[1024];
+	char *new_name;
+	size_t new_name_len;
 	int rc = 0;
 	struct DIRECT *ent;
 	struct stat sb;
 	DIR *dir;

+	new_name = malloc (1024);
+	if (NULL == new_name) {
+		return -1;
+	}
+	new_name_len = 1024;
+
 	/*
 	 * Make certain the directory exists.  This routine is called
-	 * directory by the invoker, or recursively.
+	 * directly by the invoker, or recursively.
 	 */

-	if (access (root, F_OK) != 0)
+	if (access (root, F_OK) != 0) {
+		free (new_name);
 		return -1;
+	}

 	/*
 	 * Open the directory and read each entry.  Every entry is tested
 	 * to see if it is a directory, and if so this routine is called
-	 * recursively.  If not, it is checked to see if it is owned by
-	 * old user ID.
+	 * recursively.  If not, it is checked to see if an ownership
+	 * shall be changed.
 	 */

-	if (!(dir = opendir (root)))
+	dir = opendir (root);
+	if (NULL == dir) {
+		free (new_name);
 		return -1;
+	}

 	while ((ent = readdir (dir))) {
+		size_t ent_name_len;
+		uid_t tmpuid = (uid_t) -1;
+		gid_t tmpgid = (gid_t) -1;

 		/*
 		 * Skip the "." and ".." entries
 		 */

-		if (strcmp (ent->d_name, ".") == 0 ||
-		    strcmp (ent->d_name, "..") == 0)
+		if (   (strcmp (ent->d_name, ".") == 0)
+		    || (strcmp (ent->d_name, "..") == 0)) {
 			continue;
+		}

 		/*
 		 * Make the filename for both the source and the
 		 * destination files.
 		 */

-		if (strlen (root) + strlen (ent->d_name) + 2 > sizeof new_name)
-			break;
+		ent_name_len = strlen (root) + strlen (ent->d_name) + 2;
+		if (ent_name_len > new_name_len) {
+			/*@only@*/char *tmp = realloc (new_name, ent_name_len);
+			if (NULL == tmp) {
+				rc = -1;
+				break;
+			}
+			new_name = tmp;
+			new_name_len = ent_name_len;
+		}

-		snprintf (new_name, sizeof new_name, "%s/%s", root,
-			  ent->d_name);
+		(void) snprintf (new_name, new_name_len, "%s/%s", root, ent->d_name);

 		/* Don't follow symbolic links! */
-		if (LSTAT (new_name, &sb) == -1)
+		if (LSTAT (new_name, &sb) == -1) {
 			continue;
+		}

 		if (S_ISDIR (sb.st_mode) && !S_ISLNK (sb.st_mode)) {

@@ -104,29 +138,64 @@ chown_tree (const char *root, uid_t old_uid, uid_t new_uid, gid_t old_gid,
 			 * Do the entire subdirectory.
 			 */

-			if ((rc = chown_tree (new_name, old_uid, new_uid,
-					      old_gid, new_gid)))
+			rc = chown_tree (new_name, old_uid, new_uid,
+			                 old_gid, new_gid);
+			if (0 != rc) {
 				break;
+			}
 		}
 #ifndef HAVE_LCHOWN
 		/* don't use chown (follows symbolic links!) */
-		if (S_ISLNK (sb.st_mode))
+		if (S_ISLNK (sb.st_mode)) {
 			continue;
+		}
 #endif
-		if (sb.st_uid == old_uid)
-			LCHOWN (new_name, new_uid,
-				sb.st_gid == old_gid ? new_gid : sb.st_gid);
+		/*
+		 * By default, the IDs are not changed (-1).
+		 *
+		 * If the file is not owned by the user, the owner is not
+		 * changed.
+		 *
+		 * If the file is not group-owned by the group, the
+		 * group-owner is not changed.
+		 */
+		if (((uid_t) -1 == old_uid) || (sb.st_uid == old_uid)) {
+			tmpuid = new_uid;
+		}
+		if (((gid_t) -1 == old_gid) || (sb.st_gid == old_gid)) {
+			tmpgid = new_gid;
+		}
+		if (((uid_t) -1 != tmpuid) || ((gid_t) -1 != tmpgid)) {
+			rc = LCHOWN (new_name, tmpuid, tmpgid);
+			if (0 != rc) {
+				break;
+			}
+		}
 	}
-	closedir (dir);
+
+	free (new_name);
+	(void) closedir (dir);

 	/*
 	 * Now do the root of the tree
 	 */

-	if (!stat (root, &sb)) {
-		if (sb.st_uid == old_uid)
-			LCHOWN (root, new_uid,
-				sb.st_gid == old_gid ? new_gid : sb.st_gid);
+	if ((0 == rc) && (stat (root, &sb) == 0)) {
+		uid_t tmpuid = (uid_t) -1;
+		gid_t tmpgid = (gid_t) -1;
+		if (((uid_t) -1 == old_uid) || (sb.st_uid == old_uid)) {
+			tmpuid = new_uid;
+		}
+		if (((gid_t) -1 == old_gid) || (sb.st_gid == old_gid)) {
+			tmpgid = new_gid;
+		}
+		if (((uid_t) -1 != tmpuid) || ((gid_t) -1 != tmpgid)) {
+			rc = LCHOWN (root, tmpuid, tmpgid);
+		}
+	} else {
+		rc = -1;
 	}
+
 	return rc;
 }
+
--- a/libmisc/chowntty.c
+++ b/libmisc/chowntty.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 2001, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007       , Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -43,31 +43,14 @@
 #include "defines.h"
 #include <pwd.h>
 #include "getdef.h"
-/*
- * is_my_tty -- determine if "tty" is the same as TTY stdin is using
- */
-static int is_my_tty (const char *tty)
-{
-	struct stat by_name, by_fd;
-
-	if (stat (tty, &by_name) || fstat (0, &by_fd))
-		return 0;
-
-	if (by_name.st_rdev != by_fd.st_rdev)
-		return 0;
-	else
-		return 1;
-}

 /*
 *	chown_tty() sets the login tty to be owned by the new user ID
 *	with TTYPERM modes
 */

-void chown_tty (const char *tty, const struct passwd *info)
+void chown_tty (const struct passwd *info)
 {
-	char buf[200], full_tty[200];
-	char *group;		/* TTY group name or number */
 	struct group *grent;
 	gid_t gid;

@@ -76,45 +59,32 @@ void chown_tty (const char *tty, const struct passwd *info)
 	 * ID.  Otherwise, use the user's primary group ID.
 	 */

-	if (!(group = getdef_str ("TTYGROUP")))
-		gid = info->pw_gid;
-	else if (group[0] >= '0' && group[0] <= '9')
-		gid = atoi (group);
-	else if ((grent = getgrnam (group))) /* local, no need for xgetgrnam */
+	grent = getgr_nam_gid (getdef_str ("TTYGROUP"));
+	if (NULL != grent) {
 		gid = grent->gr_gid;
-	else
+	} else {
 		gid = info->pw_gid;
+	}

 	/*
 	 * Change the permissions on the TTY to be owned by the user with
 	 * the group as determined above.
 	 */

-	if (*tty != '/') {
-		snprintf (full_tty, sizeof full_tty, "/dev/%s", tty);
-		tty = full_tty;
-	}
-
-	if (!is_my_tty (tty)) {
-		SYSLOG ((LOG_WARN,
-			 "unable to determine TTY name, got %s\n", tty));
-		closelog ();
-		exit (1);
-	}
-
-	if (chown (tty, info->pw_uid, gid) ||
-	    chmod (tty, getdef_num ("TTYPERM", 0600))) {
+	if (   (fchown (STDIN_FILENO, info->pw_uid, gid) != 0)
+	    || (fchmod (STDIN_FILENO, (mode_t)getdef_num ("TTYPERM", 0600)) != 0)) {
 		int err = errno;

-		snprintf (buf, sizeof buf, _("Unable to change tty %s"), tty);
-		perror (buf);
+		fprintf (stderr,
+		         _("Unable to change owner or mode of tty stdin: %s"),
+		         strerror (err));
 		SYSLOG ((LOG_WARN,
-			 "unable to change tty `%s' for user `%s'\n", tty,
-			 info->pw_name));
-		closelog ();
-
-		if (err != EROFS)
-			exit (1);
+		         "unable to change owner or mode of tty stdin for user `%s': %s\n",
+		         info->pw_name, strerror (err)));
+		if (EROFS != err) {
+			closelog ();
+			exit (EXIT_FAILURE);
+		}
 	}
 #ifdef __linux__
 	/*
--- a/libmisc/cleanup.c
+++ b/libmisc/cleanup.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2008 - 2011, Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdio.h>
+
+#include "prototypes.h"
+
+/*
+ * The cleanup_functions stack.
+ */
+#define CLEANUP_FUNCTIONS 10
+
+typedef /*@null@*/void * parg_t;
+
+static cleanup_function cleanup_functions[CLEANUP_FUNCTIONS];
+static parg_t cleanup_function_args[CLEANUP_FUNCTIONS];
+static pid_t cleanup_pid = 0;
+
+/*
+ * - Cleanup functions shall not fail.
+ * - You should register do_cleanups with atexit.
+ * - You should add cleanup functions to the stack with add_cleanup when
+ *   an operation is expected to be executed later, and remove it from the
+ *   stack with del_cleanup when it has been executed.
+ *
+ **/
+
+/*
+ * do_cleanups - perform the actions stored in the cleanup_functions stack.
+ *
+ * Cleanup action are not executed on exit of the processes started by the
+ * parent (first caller of add_cleanup).
+ *
+ * It is intended to be used as:
+ *     atexit (do_cleanups);
+ */
+void do_cleanups (void)
+{
+	unsigned int i;
+
+	/* Make sure there were no overflow */
+	assert (NULL == cleanup_functions[CLEANUP_FUNCTIONS-1]);
+
+	if (getpid () != cleanup_pid) {
+		return;
+	}
+
+	i = CLEANUP_FUNCTIONS;
+	do {
+		i--;
+		if (cleanup_functions[i] != NULL) {
+			cleanup_functions[i] (cleanup_function_args[i]);
+		}
+	} while (i>0);
+}
+
+/*
+ * add_cleanup - Add a cleanup_function to the cleanup_functions stack.
+ */
+void add_cleanup (/*@notnull@*/cleanup_function pcf, /*@null@*/void *arg)
+{
+	unsigned int i;
+	assert (NULL != pcf);
+
+	assert (NULL == cleanup_functions[CLEANUP_FUNCTIONS-2]);
+
+	if (0 == cleanup_pid) {
+		cleanup_pid = getpid ();
+	}
+
+	/* Add the cleanup_function at the end of the stack */
+	for (i=0; NULL != cleanup_functions[i]; i++);
+	cleanup_functions[i] = pcf;
+	cleanup_function_args[i] = arg;
+}
+
+/*
+ * del_cleanup - Remove a cleanup_function from the cleanup_functions stack.
+ */
+void del_cleanup (/*@notnull@*/cleanup_function pcf)
+{
+	unsigned int i;
+	assert (NULL != pcf);
+
+	/* Find the pcf cleanup function */
+	for (i=0; i<CLEANUP_FUNCTIONS; i++) {
+		if (cleanup_functions[i] == pcf) {
+			break;
+		}
+	}
+
+	/* Make sure the cleanup function was found */
+	assert (i<CLEANUP_FUNCTIONS);
+
+	/* Move the rest of the cleanup functions */
+	for (; i<CLEANUP_FUNCTIONS; i++) {
+		/* Make sure the cleanup function was specified only once */
+		assert (   (i == (CLEANUP_FUNCTIONS -1))
+		        || (cleanup_functions[i+1] != pcf));
+
+		if (i == (CLEANUP_FUNCTIONS -1)) {
+			cleanup_functions[i] = NULL;
+			cleanup_function_args[i] = NULL;
+		} else {
+			cleanup_functions[i] = cleanup_functions[i+1];
+			cleanup_function_args[i] = cleanup_function_args[i+1];
+		}
+
+		/* A NULL indicates the end of the stack */
+		if (NULL == cleanup_functions[i]) {
+			break;
+		}
+	}
+}
+
--- a/libmisc/cleanup_group.c
+++ b/libmisc/cleanup_group.c
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2008       , Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdio.h>
+
+#include "defines.h"
+#include "groupio.h"
+#include "sgroupio.h"
+#include "prototypes.h"
+
+/*
+ * cleanup_report_add_group - Report failure to add a group to the system
+ *
+ * It should be registered when it is decided to add a group to the system.
+ */
+void cleanup_report_add_group (void *group_name)
+{
+	const char *name = (const char *)group_name;
+
+	SYSLOG ((LOG_ERR, "failed to add group %s", name));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_GROUP, Prog,
+	              "",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+/*
+ * cleanup_report_del_group - Report failure to remove a group from the system
+ *
+ * It should be registered when it is decided to remove a group from the system.
+ */
+void cleanup_report_del_group (void *group_name)
+{
+	const char *name = (const char *)group_name;
+
+	SYSLOG ((LOG_ERR, "failed to remove group %s", name));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_DEL_GROUP, Prog,
+	              "",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+void cleanup_report_mod_group (void *cleanup_info)
+{
+	const struct cleanup_info_mod *info;
+	info = (const struct cleanup_info_mod *)cleanup_info;
+
+	SYSLOG ((LOG_ERR,
+	         "failed to change %s (%s)",
+	         gr_dbname (),
+	         info->action));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_USER_ACCT, Prog,
+	              info->audit_msg,
+	              info->name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+#ifdef SHADOWGRP
+void cleanup_report_mod_gshadow (void *cleanup_info)
+{
+	const struct cleanup_info_mod *info;
+	info = (const struct cleanup_info_mod *)cleanup_info;
+
+	SYSLOG ((LOG_ERR,
+	         "failed to change %s (%s)",
+	         sgr_dbname (),
+	         info->action));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_USER_ACCT, Prog,
+	              info->audit_msg,
+	              info->name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+#endif
+
+/*
+ * cleanup_report_add_group_group - Report failure to add a group to group
+ *
+ * It should be registered when it is decided to add a group to the
+ * group database.
+ */
+void cleanup_report_add_group_group (void *group_name)
+{
+	const char *name = (const char *)group_name;
+
+	SYSLOG ((LOG_ERR, "failed to add group %s to %s", name, gr_dbname ()));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_GROUP, Prog,
+	              "adding group to /etc/group",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+#ifdef SHADOWGRP
+/*
+ * cleanup_report_add_group_gshadow - Report failure to add a group to gshadow
+ *
+ * It should be registered when it is decided to add a group to the
+ * gshadow database.
+ */
+void cleanup_report_add_group_gshadow (void *group_name)
+{
+	const char *name = (const char *)group_name;
+
+	SYSLOG ((LOG_ERR, "failed to add group %s to %s", name, sgr_dbname ()));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_GROUP, Prog,
+	              "adding group to /etc/gshadow",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+#endif
+
+/*
+ * cleanup_report_del_group_group - Report failure to remove a group from the
+ *                                  regular group database
+ *
+ * It should be registered when it is decided to remove a group from the
+ * regular group database.
+ */
+void cleanup_report_del_group_group (void *group_name)
+{
+	const char *name = (const char *)group_name;
+
+	SYSLOG ((LOG_ERR,
+	         "failed to remove group %s from %s",
+	         name, gr_dbname ()));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_GROUP, Prog,
+	              "removing group from /etc/group",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+#ifdef SHADOWGRP
+/*
+ * cleanup_report_del_group_gshadow - Report failure to remove a group from
+ *                                    gshadow
+ *
+ * It should be registered when it is decided to remove a group from the
+ * gshadow database.
+ */
+void cleanup_report_del_group_gshadow (void *group_name)
+{
+	const char *name = (const char *)group_name;
+
+	SYSLOG ((LOG_ERR,
+	         "failed to remove group %s from %s",
+	         name, sgr_dbname ()));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_GROUP, Prog,
+	              "removing group from /etc/gshadow",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+#endif
+
+/*
+ * cleanup_unlock_group - Unlock the group file
+ *
+ * It should be registered after the group file is successfully locked.
+ */
+void cleanup_unlock_group (unused void *arg)
+{
+	if (gr_unlock () == 0) {
+		fprintf (stderr,
+		         _("%s: failed to unlock %s\n"),
+		         Prog, gr_dbname ());
+		SYSLOG ((LOG_ERR, "failed to unlock %s", gr_dbname ()));
+#ifdef WITH_AUDIT
+		audit_logger_message ("unlocking group file",
+		                      SHADOW_AUDIT_FAILURE);
+#endif
+	}
+}
+
+#ifdef SHADOWGRP
+/*
+ * cleanup_unlock_gshadow - Unlock the gshadow file
+ *
+ * It should be registered after the gshadow file is successfully locked.
+ */
+void cleanup_unlock_gshadow (unused void *arg)
+{
+	if (sgr_unlock () == 0) {
+		fprintf (stderr,
+		         _("%s: failed to unlock %s\n"),
+		         Prog, sgr_dbname ());
+		SYSLOG ((LOG_ERR, "failed to unlock %s", sgr_dbname ()));
+#ifdef WITH_AUDIT
+		audit_logger_message ("unlocking gshadow file",
+		                      SHADOW_AUDIT_FAILURE);
+#endif
+	}
+}
+#endif
+
--- a/libmisc/cleanup_user.c
+++ b/libmisc/cleanup_user.c
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2008       , Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdio.h>
+
+#include "defines.h"
+#include "pwio.h"
+#include "shadowio.h"
+#include "prototypes.h"
+
+/*
+ * cleanup_report_add_user - Report failure to add an user to the system
+ *
+ * It should be registered when it is decided to add an user to the system.
+ */
+void cleanup_report_add_user (void *user_name)
+{
+	const char *name = (const char *)user_name;
+
+	SYSLOG ((LOG_ERR, "failed to add user %s", name));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_USER, Prog,
+	              "",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+void cleanup_report_mod_passwd (void *cleanup_info)
+{
+	const struct cleanup_info_mod *info;
+	info = (const struct cleanup_info_mod *)cleanup_info;
+
+	SYSLOG ((LOG_ERR,
+	         "failed to change %s (%s)",
+	         pw_dbname (),
+	         info->action));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_USER_ACCT, Prog,
+	              info->audit_msg,
+	              info->name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+/*
+ * cleanup_report_add_user_passwd - Report failure to add an user to
+ * /etc/passwd
+ *
+ * It should be registered when it is decided to add an user to the
+ * /etc/passwd database.
+ */
+void cleanup_report_add_user_passwd (void *user_name)
+{
+	const char *name = (const char *)user_name;
+
+	SYSLOG ((LOG_ERR, "failed to add user %s to %s", name, pw_dbname ()));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_USER, Prog,
+	              "adding user to /etc/passwd",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+/*
+ * cleanup_report_add_user_shadow - Report failure to add an user to
+ * /etc/shadow
+ *
+ * It should be registered when it is decided to add an user to the
+ * /etc/shadow database.
+ */
+void cleanup_report_add_user_shadow (void *user_name)
+{
+	const char *name = (const char *)user_name;
+
+	SYSLOG ((LOG_ERR, "failed to add user %s to %s", name, spw_dbname ()));
+#ifdef WITH_AUDIT
+	audit_logger (AUDIT_ADD_USER, Prog,
+	              "adding user to /etc/shadow",
+	              name, AUDIT_NO_ID,
+	              SHADOW_AUDIT_FAILURE);
+#endif
+}
+
+/*
+ * cleanup_unlock_passwd - Unlock the /etc/passwd database
+ *
+ * It should be registered after the passwd database is successfully locked.
+ */
+void cleanup_unlock_passwd (unused void *arg)
+{
+	if (pw_unlock () == 0) {
+		fprintf (stderr,
+		         _("%s: failed to unlock %s\n"),
+		         Prog, pw_dbname ());
+		SYSLOG ((LOG_ERR, "failed to unlock %s", pw_dbname ()));
+#ifdef WITH_AUDIT
+		audit_logger_message ("unlocking passwd file",
+		                      SHADOW_AUDIT_FAILURE);
+#endif
+	}
+}
+
+/*
+ * cleanup_unlock_shadow - Unlock the /etc/shadow database
+ *
+ * It should be registered after the shadow database is successfully locked.
+ */
+void cleanup_unlock_shadow (unused void *arg)
+{
+	if (spw_unlock () == 0) {
+		fprintf (stderr,
+		         _("%s: failed to unlock %s\n"),
+		         Prog, spw_dbname ());
+		SYSLOG ((LOG_ERR, "failed to unlock %s", spw_dbname ()));
+#ifdef WITH_AUDIT
+		audit_logger_message ("unlocking shadow file",
+		                      SHADOW_AUDIT_FAILURE);
+#endif
+	}
+}
+
--- a/libmisc/console.c
+++ b/libmisc/console.c
@@ -3,7 +3,7 @@
 * Copyright (c) 1991       , Chip Rosenthal
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -40,25 +40,28 @@
 #ident "$Id$"

 /* local function prototypes */
-static int is_listed (const char *cfgin, const char *tty, int def);
+static bool is_listed (const char *cfgin, const char *tty, bool def);

 /*
 * This is now rather generic function which decides if "tty" is listed
 * under "cfgin" in config (directly or indirectly). Fallback to default if
 * something is bad.
 */
-static int is_listed (const char *cfgin, const char *tty, int def)
+static bool is_listed (const char *cfgin, const char *tty, bool def)
 {
 	FILE *fp;
-	char buf[200], *cons, *s;
+	char buf[200], *s;
+	const char *cons;

 	/*
 	 * If the CONSOLE configuration definition isn't given,
 	 * fallback to default.
 	 */

-	if ((cons = getdef_str (cfgin)) == NULL)
+	cons = getdef_str (cfgin);
+	if (NULL == cons) {
 		return def;
+	}

 	/*
 	 * If this isn't a filename, then it is a ":" delimited list of
@@ -66,14 +69,17 @@ static int is_listed (const char *cfgin, const char *tty, int def)
 	 */

 	if (*cons != '/') {
-		cons = strcpy (buf, cons);
-		while ((s = strtok (cons, ":")) != NULL) {
-			if (strcmp (s, tty) == 0)
-				return 1;
+		char *pbuf;
+		strcpy (buf, cons);
+		pbuf = &buf[0];
+		while ((s = strtok (pbuf, ":")) != NULL) {
+			if (strcmp (s, tty) == 0) {
+				return true;
+			}

-			cons = NULL;
+			pbuf = NULL;
 		}
-		return 0;
+		return false;
 	}

 	/*
@@ -81,18 +87,20 @@ static int is_listed (const char *cfgin, const char *tty, int def)
 	 * console - otherwise root will never be allowed to login.
 	 */

-	if ((fp = fopen (cons, "r")) == NULL)
+	fp = fopen (cons, "r");
+	if (NULL == fp) {
 		return def;
+	}

 	/*
 	 * See if this tty is listed in the console file.
 	 */

-	while (fgets (buf, sizeof (buf), fp) != NULL) {
+	while (fgets (buf, (int) sizeof (buf), fp) != NULL) {
 		buf[strlen (buf) - 1] = '\0';
 		if (strcmp (buf, tty) == 0) {
 			(void) fclose (fp);
-			return 1;
+			return true;
 		}
 	}

@@ -101,7 +109,7 @@ static int is_listed (const char *cfgin, const char *tty, int def)
 	 */

 	(void) fclose (fp);
-	return 0;
+	return false;
 }

 /*
@@ -114,7 +122,12 @@ static int is_listed (const char *cfgin, const char *tty, int def)
 * that would allow an unauthorized root login.
 */

-int console (const char *tty)
+bool console (const char *tty)
 {
-	return is_listed ("CONSOLE", tty, 1);
+	if (strncmp (tty, "/dev/", 5) == 0) {
+		tty += 5;
+	}
+
+	return is_listed ("CONSOLE", tty, true);
 }
+
--- a/libmisc/copydir.c
+++ b/libmisc/copydir.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1991 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 2001, Marek Michałkiewicz
 * Copyright (c) 2003 - 2006, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,7 @@

 #ident "$Id$"

+#include <assert.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/time.h>
@@ -43,78 +44,104 @@
 #include "defines.h"
 #ifdef WITH_SELINUX
 #include <selinux/selinux.h>
-static int selinux_enabled = -1;
-#endif
-static const char *src_orig;
-static const char *dst_orig;
+#endif				/* WITH_SELINUX */
+#if defined(WITH_ACL) || defined(WITH_ATTR)
+#include <stdarg.h>
+#include <attr/error_context.h>
+#endif				/* WITH_ACL || WITH_ATTR */
+#ifdef WITH_ACL
+#include <acl/libacl.h>
+#endif				/* WITH_ACL */
+#ifdef WITH_ATTR
+#include <attr/libattr.h>
+#endif				/* WITH_ATTR */
+
+
+static /*@null@*/const char *src_orig;
+static /*@null@*/const char *dst_orig;

 struct link_name {
 	dev_t ln_dev;
 	ino_t ln_ino;
-	int ln_count;
+	nlink_t ln_count;
 	char *ln_name;
-	struct link_name *ln_next;
+	/*@dependent@*/struct link_name *ln_next;
 };
-static struct link_name *links;
+static /*@exposed@*/struct link_name *links;

 static int copy_entry (const char *src, const char *dst,
-                       long int uid, long int gid);
+                       bool reset_selinux,
+                       uid_t old_uid, uid_t new_uid,
+                       gid_t old_gid, gid_t new_gid);
 static int copy_dir (const char *src, const char *dst,
-                     const struct stat *statp, const struct timeval mt[2],
-                     long int uid, long int gid);
+                     bool reset_selinux,
+                     const struct stat *statp, const struct timeval mt[],
+                     uid_t old_uid, uid_t new_uid,
+                     gid_t old_gid, gid_t new_gid);
 #ifdef	S_IFLNK
+static /*@null@*/char *readlink_malloc (const char *filename);
 static int copy_symlink (const char *src, const char *dst,
-                         const struct stat *statp, const struct timeval mt[2],
-                         long int uid, long int gid);
-#endif
-static int copy_hardlink (const char *src, const char *dst,
+                         unused bool reset_selinux,
+                         const struct stat *statp, const struct timeval mt[],
+                         uid_t old_uid, uid_t new_uid,
+                         gid_t old_gid, gid_t new_gid);
+#endif				/* S_IFLNK */
+static int copy_hardlink (const char *dst,
+                          unused bool reset_selinux,
                          struct link_name *lp);
-static int copy_special (const char *dst,
-                         const struct stat *statp, const struct timeval mt[2],
-                         long int uid, long int gid);
+static int copy_special (const char *src, const char *dst,
+                         bool reset_selinux,
+                         const struct stat *statp, const struct timeval mt[],
+                         uid_t old_uid, uid_t new_uid,
+                         gid_t old_gid, gid_t new_gid);
 static int copy_file (const char *src, const char *dst,
-                      const struct stat *statp, const struct timeval mt[2],
-                      long int uid, long int gid);
+                      bool reset_selinux,
+                      const struct stat *statp, const struct timeval mt[],
+                      uid_t old_uid, uid_t new_uid,
+                      gid_t old_gid, gid_t new_gid);
+static int chown_if_needed (const char *dst, const struct stat *statp,
+                            uid_t old_uid, uid_t new_uid,
+                            gid_t old_gid, gid_t new_gid);
+static int lchown_if_needed (const char *dst, const struct stat *statp,
+                             uid_t old_uid, uid_t new_uid,
+                             gid_t old_gid, gid_t new_gid);
+static int fchown_if_needed (int fdst, const struct stat *statp,
+                             uid_t old_uid, uid_t new_uid,
+                             gid_t old_gid, gid_t new_gid);

-#ifdef WITH_SELINUX
+#if defined(WITH_ACL) || defined(WITH_ATTR)
 /*
- * selinux_file_context - Set the security context before any file or
- *                        directory creation.
- *
- *	selinux_file_context () should be called before any creation of file,
- *	symlink, directory, ...
- *
+ * error_acl - format the error messages for the ACL and EQ libraries.
 */
-static int selinux_file_context (const char *dst_name)
+static void error_acl (struct error_context *ctx, const char *fmt, ...)
 {
-	security_context_t scontext = NULL;
+	va_list ap;

-	if (selinux_enabled < 0) {
-		selinux_enabled = is_selinux_enabled () > 0;
+	/* ignore the case when destination does not support ACLs 
+	 * or extended attributes */
+	if (ENOTSUP == errno) {
+		errno = 0;
+		return;
 	}
-	if (selinux_enabled) {
-		/* Get the default security context for this file */
-		if (matchpathcon (dst_name, 0, &scontext) < 0) {
-			if (security_getenforce () != 0) {
-				return 1;
-			}
-		}
-		/* Set the security context for the next created file */
-		if (setfscreatecon (scontext) < 0) {
-			if (security_getenforce () != 0) {
-				return 1;
-			}
-		}
-		freecon (scontext);
+
+	va_start (ap, fmt);
+	(void) fprintf (stderr, _("%s: "), Prog);
+	if (vfprintf (stderr, fmt, ap) != 0) {
+		(void) fputs (_(": "), stderr);
 	}
-	return 0;
+	(void) fprintf (stderr, "%s\n", strerror (errno));
+	va_end (ap);
 }
-#endif
+
+static struct error_context ctx = {
+	error_acl
+};
+#endif				/* WITH_ACL || WITH_ATTR */

 /*
 * remove_link - delete a link from the linked list
 */
-static void remove_link (struct link_name *ln)
+static void remove_link (/*@only@*/struct link_name *ln)
 {
 	struct link_name *lp;

@@ -131,6 +158,8 @@ static void remove_link (struct link_name *ln)
 	}

 	if (NULL == lp) {
+		free (ln->ln_name);
+		free (ln);
 		return;
 	}

@@ -143,15 +172,19 @@ static void remove_link (struct link_name *ln)
 * check_link - see if a file is really a link
 */

-static struct link_name *check_link (const char *name, const struct stat *sb)
+static /*@exposed@*/ /*@null@*/struct link_name *check_link (const char *name, const struct stat *sb)
 {
 	struct link_name *lp;
-	int src_len;
-	int dst_len;
-	int name_len;
-	int len;
+	size_t src_len;
+	size_t dst_len;
+	size_t name_len;
+	size_t len;

-	for (lp = links; lp; lp = lp->ln_next) {
+	/* copy_tree () must be the entry point */
+	assert (NULL != src_orig);
+	assert (NULL != dst_orig);
+
+	for (lp = links; NULL != lp; lp = lp->ln_next) {
 		if ((lp->ln_dev == sb->st_dev) && (lp->ln_ino == sb->st_ino)) {
 			return lp;
 		}
@@ -169,8 +202,8 @@ static struct link_name *check_link (const char *name, const struct stat *sb)
 	lp->ln_ino = sb->st_ino;
 	lp->ln_count = sb->st_nlink;
 	len = name_len - src_len + dst_len + 1;
-	lp->ln_name = xmalloc (len);
-	snprintf (lp->ln_name, len, "%s%s", dst_orig, name + src_len);
+	lp->ln_name = (char *) xmalloc (len);
+	(void) snprintf (lp->ln_name, len, "%s%s", dst_orig, name + src_len);
 	lp->ln_next = links;
 	links = lp;

@@ -182,17 +215,49 @@ static struct link_name *check_link (const char *name, const struct stat *sb)
 *
 *	copy_tree() walks a directory tree and copies ordinary files
 *	as it goes.
+ *
+ *	When reset_selinux is enabled, extended attributes (and thus
+ *	SELinux attributes) are not copied.
+ *
+ *	old_uid and new_uid are used to set the ownership of the copied
+ *	files. Unless old_uid is set to -1, only the files owned by
+ *	old_uid have their ownership changed to new_uid. In addition, if
+ *	new_uid is set to -1, no ownership will be changed.
+ *
+ *	The same logic applies for the group-ownership and
+ *	old_gid/new_gid.
 */
 int copy_tree (const char *src_root, const char *dst_root,
-               long int uid, long int gid)
+               bool copy_root, bool reset_selinux,
+               uid_t old_uid, uid_t new_uid,
+               gid_t old_gid, gid_t new_gid)
 {
-	char src_name[1024];
-	char dst_name[1024];
 	int err = 0;
-	int set_orig = 0;
+	bool set_orig = false;
 	struct DIRECT *ent;
 	DIR *dir;

+	if (copy_root) {
+		struct stat sb;
+		if (access (dst_root, F_OK) == 0) {
+			return -1;
+		}
+
+		if (LSTAT (src_root, &sb) == -1) {
+			return -1;
+		}
+
+		if (!S_ISDIR (sb.st_mode)) {
+			fprintf (stderr,
+			         "%s: %s is not a directory",
+			         Prog, src_root);
+			return -1;
+		}
+
+		return copy_entry (src_root, dst_root, reset_selinux,
+		                   old_uid, new_uid, old_gid, new_gid);
+	}
+
 	/*
 	 * Make certain both directories exist.  This routine is called
 	 * after the home directory is created, or recursively after the
@@ -216,10 +281,10 @@ int copy_tree (const char *src_root, const char *dst_root,
 		return -1;
 	}

-	if (src_orig == 0) {
+	if (src_orig == NULL) {
 		src_orig = src_root;
 		dst_orig = dst_root;
-		set_orig++;
+		set_orig = true;
 	}
 	while ((0 == err) && (ent = readdir (dir)) != NULL) {
 		/*
@@ -227,35 +292,66 @@ int copy_tree (const char *src_root, const char *dst_root,
 		 */
 		if ((strcmp (ent->d_name, ".") != 0) &&
 		    (strcmp (ent->d_name, "..") != 0)) {
-			/*
-			 * Make sure the resulting source and destination
-			 * filenames will fit in their buffers.
-			 */
-			if (   (strlen (src_root) + strlen (ent->d_name) + 2 >
-			        sizeof src_name)
-			    || (strlen (dst_root) + strlen (ent->d_name) + 2 >
-			        sizeof dst_name)) {
+			char *src_name;
+			char *dst_name;
+			size_t src_len = strlen (ent->d_name) + 2;
+			size_t dst_len = strlen (ent->d_name) + 2;
+			src_len += strlen (src_root);
+			dst_len += strlen (dst_root);
+
+			src_name = (char *) malloc (src_len);
+			dst_name = (char *) malloc (dst_len);
+
+			if ((NULL == src_name) || (NULL == dst_name)) {
 				err = -1;
 			} else {
 				/*
 				 * Build the filename for both the source and
 				 * the destination files.
 				 */
-				snprintf (src_name, sizeof src_name, "%s/%s",
-				          src_root, ent->d_name);
-				snprintf (dst_name, sizeof dst_name, "%s/%s",
-				          dst_root, ent->d_name);
+				(void) snprintf (src_name, src_len, "%s/%s",
+				                 src_root, ent->d_name);
+				(void) snprintf (dst_name, dst_len, "%s/%s",
+				                 dst_root, ent->d_name);

-				err = copy_entry (src_name, dst_name, uid, gid);
+				err = copy_entry (src_name, dst_name,
+				                  reset_selinux,
+				                  old_uid, new_uid,
+				                  old_gid, new_gid);
+			}
+			if (NULL != src_name) {
+				free (src_name);
+			}
+			if (NULL != dst_name) {
+				free (dst_name);
 			}
 		}
 	}
 	(void) closedir (dir);

 	if (set_orig) {
-		src_orig = 0;
-		dst_orig = 0;
+		src_orig = NULL;
+		dst_orig = NULL;
+		/* FIXME: clean links
+		 * Since there can be hardlinks elsewhere on the device,
+		 * we cannot check that all the hardlinks were found:
+		assert (NULL == links);
+		 */
 	}
+
+#ifdef WITH_SELINUX
+	/* Reset SELinux to create files with default contexts.
+	 * Note that the context is only reset on exit of copy_tree (it is
+	 * assumed that the program would quit without needing a restored
+	 * context if copy_tree failed previously), and that copy_tree can
+	 * be called recursively (hence the context is set on the
+	 * sub-functions of copy_entry).
+	 */
+	if (reset_selinux_file_context () != 0) {
+		err = -1;
+	}
+#endif				/* WITH_SELINUX */
+
 	return err;
 }

@@ -269,13 +365,19 @@ int copy_tree (const char *src_root, const char *dst_root,
 *
 *	The access and modification time will not be modified.
 *
- *	The permissions will be set to uid/gid.
+ *	The permissions will be set to new_uid/new_gid.
 *
- *	If uid (resp. gid) is equal to -1, the user (resp. group) will
+ *	If new_uid (resp. new_gid) is equal to -1, the user (resp. group) will
 *	not be modified.
+ *
+ *	Only the files owned (resp. group-owned) by old_uid (resp.
+ *	old_gid) will be modified, unless old_uid (resp. old_gid) is set
+ *	to -1.
 */
 static int copy_entry (const char *src, const char *dst,
-                       long int uid, long int gid)
+                       bool reset_selinux,
+                       uid_t old_uid, uid_t new_uid,
+                       gid_t old_gid, gid_t new_gid)
 {
 	int err = 0;
 	struct stat sb;
@@ -285,20 +387,33 @@ static int copy_entry (const char *src, const char *dst,
 	if (LSTAT (src, &sb) == -1) {
 		/* If we cannot stat the file, do not care. */
 	} else {
-#if  defined(_BSD_SOURCE) || defined(_SVID_SOURCE)
+#ifdef HAVE_STRUCT_STAT_ST_ATIM
 		mt[0].tv_sec  = sb.st_atim.tv_sec;
 		mt[0].tv_usec = sb.st_atim.tv_nsec / 1000;
+#else				/* !HAVE_STRUCT_STAT_ST_ATIM */
+		mt[0].tv_sec  = sb.st_atime;
+# ifdef HAVE_STRUCT_STAT_ST_ATIMENSEC
+		mt[0].tv_usec = sb.st_atimensec / 1000;
+# else				/* !HAVE_STRUCT_STAT_ST_ATIMENSEC */
+		mt[0].tv_usec = 0;
+# endif				/* !HAVE_STRUCT_STAT_ST_ATIMENSEC */
+#endif				/* !HAVE_STRUCT_STAT_ST_ATIM */
+
+#ifdef HAVE_STRUCT_STAT_ST_MTIM
 		mt[1].tv_sec  = sb.st_mtim.tv_sec;
 		mt[1].tv_usec = sb.st_mtim.tv_nsec / 1000;
-#else
-		mt[0].tv_sec  = sb.st_atime;
-		mt[0].tv_usec = sb.st_atimensec / 1000;
+#else				/* !HAVE_STRUCT_STAT_ST_MTIM */
 		mt[1].tv_sec  = sb.st_mtime;
+# ifdef HAVE_STRUCT_STAT_ST_MTIMENSEC
 		mt[1].tv_usec = sb.st_mtimensec / 1000;
-#endif
+# else				/* !HAVE_STRUCT_STAT_ST_MTIMENSEC */
+		mt[1].tv_usec = 0;
+# endif				/* !HAVE_STRUCT_STAT_ST_MTIMENSEC */
+#endif				/* !HAVE_STRUCT_STAT_ST_MTIM */

 		if (S_ISDIR (sb.st_mode)) {
-			err = copy_dir (src, dst, &sb, mt, uid, gid);
+			err = copy_dir (src, dst, reset_selinux, &sb, mt,
+			                old_uid, new_uid, old_gid, new_gid);
 		}

 #ifdef	S_IFLNK
@@ -307,16 +422,17 @@ static int copy_entry (const char *src, const char *dst,
 		 */

 		else if (S_ISLNK (sb.st_mode)) {
-			err = copy_symlink (src, dst, &sb, mt, uid, gid);
+			err = copy_symlink (src, dst, reset_selinux, &sb, mt,
+			                    old_uid, new_uid, old_gid, new_gid);
 		}
-#endif
+#endif				/* S_IFLNK */

 		/*
 		 * See if this is a previously copied link
 		 */

 		else if ((lp = check_link (src, &sb)) != NULL) {
-			err = copy_hardlink (src, dst, lp);
+			err = copy_hardlink (dst, reset_selinux, lp);
 		}

 		/*
@@ -326,7 +442,8 @@ static int copy_entry (const char *src, const char *dst,
 		 */

 		else if (!S_ISREG (sb.st_mode)) {
-			err = copy_special (dst, &sb, mt, uid, gid);
+			err = copy_special (src, dst, reset_selinux, &sb, mt,
+			                    old_uid, new_uid, old_gid, new_gid);
 		}

 		/*
@@ -335,7 +452,8 @@ static int copy_entry (const char *src, const char *dst,
 		 */

 		else {
-			err = copy_file (src, dst, &sb, mt, uid, gid);
+			err = copy_file (src, dst, reset_selinux, &sb, mt,
+			                 old_uid, new_uid, old_gid, new_gid);
 		}
 	}

@@ -347,14 +465,16 @@ static int copy_entry (const char *src, const char *dst,
 *
 *	Copy a directory (recursively) from src to dst.
 *
- *	statp, mt, uid, gid are used to set the access and modification and the
- *	access rights.
+ *	statp, mt, old_uid, new_uid, old_gid, and new_gid are used to set
+ *	the access and modification and the access rights.
 *
 *	Return 0 on success, -1 on error.
 */
 static int copy_dir (const char *src, const char *dst,
-                     const struct stat *statp, const struct timeval mt[2],
-                     long int uid, long int gid)
+                     bool reset_selinux,
+                     const struct stat *statp, const struct timeval mt[],
+                     uid_t old_uid, uid_t new_uid,
+                     gid_t old_gid, gid_t new_gid)
 {
 	int err = 0;

@@ -364,14 +484,33 @@ static int copy_dir (const char *src, const char *dst,
 	 */

 #ifdef WITH_SELINUX
-	selinux_file_context (dst);
-#endif
+	if (set_selinux_file_context (dst) != 0) {
+		return -1;
+	}
+#endif				/* WITH_SELINUX */
 	if (   (mkdir (dst, statp->st_mode) != 0)
-	    || (chown (dst,
-	               (uid == - 1) ? statp->st_uid : (uid_t) uid,
-	               (gid == - 1) ? statp->st_gid : (gid_t) gid) != 0)
+	    || (chown_if_needed (dst, statp,
+	                         old_uid, new_uid, old_gid, new_gid) != 0)
+#ifdef WITH_ACL
+	    || (   (perm_copy_file (src, dst, &ctx) != 0)
+	        && (errno != 0))
+#else				/* !WITH_ACL */
 	    || (chmod (dst, statp->st_mode) != 0)
-	    || (copy_tree (src, dst, uid, gid) != 0)
+#endif				/* !WITH_ACL */
+#ifdef WITH_ATTR
+	/*
+	 * If the third parameter is NULL, all extended attributes
+	 * except those that define Access Control Lists are copied.
+	 * ACLs are excluded by default because copying them between
+	 * file systems with and without ACL support needs some
+	 * additional logic so that no unexpected permissions result.
+	 */
+	    || (   !reset_selinux
+	        && (attr_copy_file (src, dst, NULL, &ctx) != 0)
+	        && (errno != 0))
+#endif				/* WITH_ATTR */
+	    || (copy_tree (src, dst, false, reset_selinux,
+	                   old_uid, new_uid, old_gid, new_gid) != 0)
 	    || (utimes (dst, mt) != 0)) {
 		err = -1;
 	}
@@ -380,24 +519,63 @@ static int copy_dir (const char *src, const char *dst,
 }

 #ifdef	S_IFLNK
+/*
+ * readlink_malloc - wrapper for readlink
+ *
+ * return NULL on error.
+ * The return string shall be freed by the caller.
+ */
+static /*@null@*/char *readlink_malloc (const char *filename)
+{
+	size_t size = 1024;
+
+	while (true) {
+		ssize_t nchars;
+		char *buffer = (char *) malloc (size);
+		if (NULL == buffer) {
+			return NULL;
+		}
+
+		nchars = readlink (filename, buffer, size);
+
+		if (nchars < 0) {
+			free(buffer);
+			return NULL;
+		}
+
+		if ((size_t) nchars < size) { /* The buffer was large enough */
+			/* readlink does not nul-terminate */
+			buffer[nchars] = '\0';
+			return buffer;
+		}
+
+		/* Try again with a bigger buffer */
+		free (buffer);
+		size *= 2;
+	}
+}
+
 /*
 * copy_symlink - copy a symlink
 *
 *	Copy a symlink from src to dst.
 *
- *	statp, mt, uid, gid are used to set the access and modification and the
- *	access rights.
+ *	statp, mt, old_uid, new_uid, old_gid, and new_gid are used to set
+ *	the access and modification and the access rights.
 *
 *	Return 0 on success, -1 on error.
 */
 static int copy_symlink (const char *src, const char *dst,
-                         const struct stat *statp, const struct timeval mt[2],
-                         long int uid, long int gid)
+                         unused bool reset_selinux,
+                         const struct stat *statp, const struct timeval mt[],
+                         uid_t old_uid, uid_t new_uid,
+                         gid_t old_gid, gid_t new_gid)
 {
-	char oldlink[1024];
-	char dummy[1024];
-	int len;
-	int err = 0;
+	char *oldlink;
+
+	/* copy_tree () must be the entry point */
+	assert (NULL != src_orig);
+	assert (NULL != dst_orig);

 	/*
 	 * Get the name of the file which the link points
@@ -407,37 +585,58 @@ static int copy_symlink (const char *src, const char *dst,
 	 * destination directory name.
 	 */

-	len = readlink (src, oldlink, sizeof (oldlink) - 1);
-	if (len < 0) {
-		return -1;
-	}
-	oldlink[len] = '\0';	/* readlink() does not NUL-terminate */
-	if (strncmp (oldlink, src_orig, strlen (src_orig)) == 0) {
-		snprintf (dummy, sizeof dummy, "%s%s",
-		          dst_orig,
-		          oldlink + strlen (src_orig));
-		strcpy (oldlink, dummy);
-	}
-#ifdef WITH_SELINUX
-	selinux_file_context (dst);
-#endif
-	if (   (symlink (oldlink, dst) != 0)
-	    || (lchown (dst,
-	                (uid == -1) ? statp->st_uid : (uid_t) uid,
-	                (gid == -1) ? statp->st_gid : (gid_t) gid) != 0)) {
+	oldlink = readlink_malloc (src);
+	if (NULL == oldlink) {
 		return -1;
 	}

+	/* If src was a link to an entry of the src_orig directory itself,
+	 * create a link to the corresponding entry in the dst_orig
+	 * directory.
+	 */
+	if (strncmp (oldlink, src_orig, strlen (src_orig)) == 0) {
+		size_t len = strlen (dst_orig) + strlen (oldlink) - strlen (src_orig) + 1;
+		char *dummy = (char *) xmalloc (len);
+		(void) snprintf (dummy, len, "%s%s",
+		                 dst_orig,
+		                 oldlink + strlen (src_orig));
+		free (oldlink);
+		oldlink = dummy;
+	}
+
+#ifdef WITH_SELINUX
+	if (set_selinux_file_context (dst) != 0) {
+		free (oldlink);
+		return -1;
+	}
+#endif				/* WITH_SELINUX */
+	if (   (symlink (oldlink, dst) != 0)
+	    || (lchown_if_needed (dst, statp,
+	                          old_uid, new_uid, old_gid, new_gid) != 0)) {
+		/* FIXME: there are no modes on symlinks, right?
+		 *        ACL could be copied, but this would be much more
+		 *        complex than calling perm_copy_file.
+		 *        Ditto for Extended Attributes.
+		 *        We currently only document that ACL and Extended
+		 *        Attributes are not copied.
+		 */
+		free (oldlink);
+		return -1;
+	}
+	free (oldlink);
+
+#ifdef HAVE_LUTIMES
 	/* 2007-10-18: We don't care about
 	 *  exit status of lutimes because
 	 *  it returns ENOSYS on many system
 	 *  - not implemented
 	 */
-	lutimes (dst, mt);
+	(void) lutimes (dst, mt);
+#endif				/* HAVE_LUTIMES */

-	return err;
+	return 0;
 }
-#endif
+#endif				/* S_IFLNK */

 /*
 * copy_hardlink - copy a hardlink
@@ -446,20 +645,18 @@ static int copy_symlink (const char *src, const char *dst,
 *
 *	Return 0 on success, -1 on error.
 */
-static int copy_hardlink (const char *src, const char *dst,
+static int copy_hardlink (const char *dst,
+                          unused bool reset_selinux,
                          struct link_name *lp)
 {
-	/* TODO: selinux needed? */
+	/* FIXME: selinux, ACL, Extended Attributes needed? */

 	if (link (lp->ln_name, dst) != 0) {
 		return -1;
 	}
-	if (unlink (src) != 0) {
-		return -1;
-	}

 	/* If the file could be unlinked, decrement the links counter,
-	 * and delete the file if it was the last reference */
+	 * and forget about this link if it was the last reference */
 	lp->ln_count--;
 	if (lp->ln_count <= 0) {
 		remove_link (lp);
@@ -473,26 +670,46 @@ static int copy_hardlink (const char *src, const char *dst,
 *
 *	Copy a special file from src to dst.
 *
- *	statp, mt, uid, gid are used to set the access and modification and the
- *	access rights.
+ *	statp, mt, old_uid, new_uid, old_gid, and new_gid are used to set
+ *	the access and modification and the access rights.
 *
 *	Return 0 on success, -1 on error.
 */
-static int copy_special (const char *dst,
-                         const struct stat *statp, const struct timeval mt[2],
-                         long int uid, long int gid)
+static int copy_special (const char *src, const char *dst,
+                         bool reset_selinux,
+                         const struct stat *statp, const struct timeval mt[],
+                         uid_t old_uid, uid_t new_uid,
+                         gid_t old_gid, gid_t new_gid)
 {
 	int err = 0;

 #ifdef WITH_SELINUX
-	selinux_file_context (dst);
-#endif
+	if (set_selinux_file_context (dst) != 0) {
+		return -1;
+	}
+#endif				/* WITH_SELINUX */

 	if (   (mknod (dst, statp->st_mode & ~07777, statp->st_rdev) != 0)
-	    || (chown (dst,
-	               (uid == -1) ? statp->st_uid : (uid_t) uid,
-	               (gid == -1) ? statp->st_gid : (gid_t) gid) != 0)
+	    || (chown_if_needed (dst, statp,
+	                         old_uid, new_uid, old_gid, new_gid) != 0)
+#ifdef WITH_ACL
+	    || (   (perm_copy_file (src, dst, &ctx) != 0)
+	        && (errno != 0))
+#else				/* !WITH_ACL */
 	    || (chmod (dst, statp->st_mode & 07777) != 0)
+#endif				/* !WITH_ACL */
+#ifdef WITH_ATTR
+	/*
+	 * If the third parameter is NULL, all extended attributes
+	 * except those that define Access Control Lists are copied.
+	 * ACLs are excluded by default because copying them between
+	 * file systems with and without ACL support needs some
+	 * additional logic so that no unexpected permissions result.
+	 */
+	    || (   !reset_selinux
+	        && (attr_copy_file (src, dst, NULL, &ctx) != 0)
+	        && (errno != 0))
+#endif				/* WITH_ATTR */
 	    || (utimes (dst, mt) != 0)) {
 		err = -1;
 	}
@@ -505,144 +722,118 @@ static int copy_special (const char *dst,
 *
 *	Copy a file from src to dst.
 *
- *	statp, mt, uid, gid are used to set the access and modification and the
- *	access rights.
+ *	statp, mt, old_uid, new_uid, old_gid, and new_gid are used to set
+ *	the access and modification and the access rights.
 *
 *	Return 0 on success, -1 on error.
 */
 static int copy_file (const char *src, const char *dst,
-                      const struct stat *statp, const struct timeval mt[2],
-                      long int uid, long int gid)
+                      bool reset_selinux,
+                      const struct stat *statp, const struct timeval mt[],
+                      uid_t old_uid, uid_t new_uid,
+                      gid_t old_gid, gid_t new_gid)
 {
 	int err = 0;
 	int ifd;
 	int ofd;
 	char buf[1024];
-	int cnt;
+	ssize_t cnt;

 	ifd = open (src, O_RDONLY);
 	if (ifd < 0) {
 		return -1;
 	}
 #ifdef WITH_SELINUX
-	selinux_file_context (dst);
-#endif
-	ofd = open (dst, O_WRONLY | O_CREAT | O_TRUNC, 0);
+	if (set_selinux_file_context (dst) != 0) {
+		return -1;
+	}
+#endif				/* WITH_SELINUX */
+	ofd = open (dst, O_WRONLY | O_CREAT | O_TRUNC, statp->st_mode & 07777);
 	if (   (ofd < 0)
-	    || (chown (dst,
-	               (uid == -1) ? statp->st_uid : (uid_t) uid,
-	               (gid == -1) ? statp->st_gid : (gid_t) gid) != 0)
-	    || (chmod (dst, statp->st_mode & 07777) != 0)) {
+	    || (fchown_if_needed (ofd, statp,
+	                          old_uid, new_uid, old_gid, new_gid) != 0)
+#ifdef WITH_ACL
+	    || (   (perm_copy_fd (src, ifd, dst, ofd, &ctx) != 0)
+	        && (errno != 0))
+#else				/* !WITH_ACL */
+	    || (fchmod (ofd, statp->st_mode & 07777) != 0)
+#endif				/* !WITH_ACL */
+#ifdef WITH_ATTR
+	/*
+	 * If the third parameter is NULL, all extended attributes
+	 * except those that define Access Control Lists are copied.
+	 * ACLs are excluded by default because copying them between
+	 * file systems with and without ACL support needs some
+	 * additional logic so that no unexpected permissions result.
+	 */
+	    || (   !reset_selinux
+	        && (attr_copy_fd (src, ifd, dst, ofd, NULL, &ctx) != 0)
+	        && (errno != 0))
+#endif				/* WITH_ATTR */
+	   ) {
 		(void) close (ifd);
 		return -1;
 	}

 	while ((cnt = read (ifd, buf, sizeof buf)) > 0) {
-		if (write (ofd, buf, cnt) != cnt) {
+		if (write (ofd, buf, (size_t)cnt) != cnt) {
+			(void) close (ifd);
 			return -1;
 		}
 	}

 	(void) close (ifd);

+#ifdef HAVE_FUTIMES
 	if (futimes (ofd, mt) != 0) {
 		return -1;
 	}
+#endif				/* HAVE_FUTIMES */

 	if (close (ofd) != 0) {
 		return -1;
 	}

-	return err;
-}
-
-/*
- * remove_tree - delete a directory tree
- *
- *	remove_tree() walks a directory tree and deletes all the files
- *	and directories.
- *	At the end, it deletes the root directory itself.
- */
-
-int remove_tree (const char *root)
-{
-	char new_name[1024];
-	int err = 0;
-	struct DIRECT *ent;
-	struct stat sb;
-	DIR *dir;
-
-	/*
-	 * Make certain the directory exists.
-	 */
-
-	if (access (root, F_OK) != 0) {
+#ifndef HAVE_FUTIMES
+	if (utimes(dst, mt) != 0) {
 		return -1;
 	}
-
-	/*
-	 * Open the source directory and read each entry.  Every file
-	 * entry in the directory is copied with the UID and GID set
-	 * to the provided values.  As an added security feature only
-	 * regular files (and directories ...) are copied, and no file
-	 * is made set-ID.
-	 */
-	dir = opendir (root);
-	if (NULL == dir) {
-		return -1;
-	}
-
-	while ((ent = readdir (dir))) {
-
-		/*
-		 * Skip the "." and ".." entries
-		 */
-
-		if (strcmp (ent->d_name, ".") == 0 ||
-		    strcmp (ent->d_name, "..") == 0) {
-			continue;
-		}
-
-		/*
-		 * Make the filename for the current entry.
-		 */
-
-		if (strlen (root) + strlen (ent->d_name) + 2 > sizeof new_name) {
-			err = -1;
-			break;
-		}
-		snprintf (new_name, sizeof new_name, "%s/%s", root,
-			  ent->d_name);
-		if (LSTAT (new_name, &sb) == -1) {
-			continue;
-		}
-
-		if (S_ISDIR (sb.st_mode)) {
-			/*
-			 * Recursively delete this directory.
-			 */
-			if (remove_tree (new_name) != 0) {
-				err = -1;
-				break;
-			}
-		} else {
-			/*
-			 * Delete the file.
-			 */
-			if (unlink (new_name) != 0) {
-				err = -1;
-				break;
-			}
-		}
-	}
-	(void) closedir (dir);
-
-	if (0 == err) {
-		if (rmdir (root) != 0) {
-			err = -1;
-		}
-	}
+#endif				/* !HAVE_FUTIMES */

 	return err;
 }

+#define def_chown_if_needed(chown_function, type_dst)                  \
+static int chown_function ## _if_needed (type_dst dst,                 \
+                                         const struct stat *statp,     \
+                                         uid_t old_uid, uid_t new_uid, \
+                                         gid_t old_gid, gid_t new_gid) \
+{                                                                      \
+	uid_t tmpuid = (uid_t) -1;                                     \
+	gid_t tmpgid = (gid_t) -1;                                     \
+                                                                       \
+	/* Use new_uid if old_uid is set to -1 or if the file was      \
+	 * owned by the user. */                                       \
+	if (((uid_t) -1 == old_uid) || (statp->st_uid == old_uid)) {   \
+		tmpuid = new_uid;                                      \
+	}                                                              \
+	/* Otherwise, or if new_uid was set to -1, we keep the same    \
+	 * owner. */                                                   \
+	if ((uid_t) -1 == tmpuid) {                                    \
+		tmpuid = statp->st_uid;                                \
+	}                                                              \
+                                                                       \
+	if (((gid_t) -1 == old_gid) || (statp->st_gid == old_gid)) {   \
+		tmpgid = new_gid;                                      \
+	}                                                              \
+	if ((gid_t) -1 == tmpgid) {                                    \
+		tmpgid = statp->st_gid;                                \
+	}                                                              \
+                                                                       \
+	return chown_function (dst, tmpuid, tmpgid);                   \
+}
+
+def_chown_if_needed (chown, const char *)
+def_chown_if_needed (lchown, const char *)
+def_chown_if_needed (fchown, int)
+
--- a/libmisc/env.c
+++ b/libmisc/env.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1992, Julianne Frances Haugh
 * Copyright (c) 1996 - 1999, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2008       , Nicolas François
+ * Copyright (c) 2008 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,7 @@

 #ident "$Id$"

+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -46,7 +47,7 @@
 */
 #define NEWENVP_STEP 16
 size_t newenvc = 0;
-char **newenvp = NULL;
+/*@null@*/char **newenvp = NULL;
 extern char **environ;

 static const char *forbid[] = {
@@ -85,15 +86,18 @@ void initenv (void)
 }


-void addenv (const char *string, const char *value)
+void addenv (const char *string, /*@null@*/const char *value)
 {
 	char *cp, *newstring;
 	size_t i;
 	size_t n;

-	if (value) {
-		newstring = xmalloc (strlen (string) + strlen (value) + 2);
-		sprintf (newstring, "%s=%s", string, value);
+	if (NULL != value) {
+		size_t len = strlen (string) + strlen (value) + 2;
+		int wlen;
+		newstring = xmalloc (len);
+		wlen = snprintf (newstring, len, "%s=%s", string, value);
+		assert (wlen == (int) len -1);
 	} else {
 		newstring = xstrdup (string);
 	}
@@ -104,17 +108,21 @@ void addenv (const char *string, const char *value)
 	 */

 	cp = strchr (newstring, '=');
-	if (!cp) {
+	if (NULL == cp) {
 		free (newstring);
 		return;
 	}

 	n = (size_t) (cp - newstring);

+	/*
+	 * If this environment variable is already set, change its value.
+	 */
 	for (i = 0; i < newenvc; i++) {
-		if (strncmp (newstring, newenvp[i], n) == 0 &&
-		    (newenvp[i][n] == '=' || newenvp[i][n] == '\0'))
+		if (   (strncmp (newstring, newenvp[i], n) == 0)
+		    && (('=' == newenvp[i][n]) || ('\0' == newenvp[i][n]))) {
 			break;
+		}
 	}

 	if (i < newenvc) {
@@ -123,8 +131,15 @@ void addenv (const char *string, const char *value)
 		return;
 	}

+	/*
+	 * Otherwise, save the new environment variable
+	 */
 	newenvp[newenvc++] = newstring;

+	/*
+	 * And extend the environment if needed.
+	 */
+
 	/*
 	 * Check whether newenvc is a multiple of NEWENVP_STEP.
 	 * If so we have to resize the vector.
@@ -138,25 +153,27 @@ void addenv (const char *string, const char *value)
 		size_t newsize;

 		/*
-		 * If the resize operation succeds we can
+		 * If the resize operation succeeds we can
 		 * happily go on, else print a message.
 		 */

 		newsize = (newenvc + NEWENVP_STEP) * sizeof (char *);
 		__newenvp = (char **) realloc (newenvp, newsize);

-		if (__newenvp) {
+		if (NULL != __newenvp) {
 			/*
 			 * If this is our current environment, update
 			 * environ so that it doesn't point to some
 			 * free memory area (realloc() could move it).
 			 */
-			if (environ == newenvp)
+			if (environ == newenvp) {
 				environ = __newenvp;
+			}
 			newenvp = __newenvp;
 		} else {
-			fputs (_("Environment overflow\n"), stderr);
-			free (newenvp[--newenvc]);
+			(void) fputs (_("Environment overflow\n"), stderr);
+			newenvc--;
+			free (newenvp[newenvc]);
 		}
 	}

@@ -178,21 +195,28 @@ void set_env (int argc, char *const *argv)
 	char *cp;

 	for (; argc > 0; argc--, argv++) {
-		if (strlen (*argv) >= sizeof variable)
+		if (strlen (*argv) >= sizeof variable) {
 			continue;	/* ignore long entries */
+		}

-		if (!(cp = strchr (*argv, '='))) {
-			snprintf (variable, sizeof variable, "L%d", noname++);
+		cp = strchr (*argv, '=');
+		if (NULL == cp) {
+			int wlen;
+			wlen = snprintf (variable, sizeof variable, "L%d", noname);
+			assert (wlen < (int) sizeof(variable));
+			noname++;
 			addenv (variable, *argv);
 		} else {
 			const char **p;

-			for (p = forbid; *p; p++)
-				if (strncmp (*argv, *p, strlen (*p)) == 0)
+			for (p = forbid; NULL != *p; p++) {
+				if (strncmp (*argv, *p, strlen (*p)) == 0) {
 					break;
+				}
+			}

-			if (*p) {
-				strncpy (variable, *argv, cp - *argv);
+			if (NULL != *p) {
+				strncpy (variable, *argv, (size_t)(cp - *argv));
 				variable[cp - *argv] = '\0';
 				printf (_("You may not change $%s\n"),
 					variable);
@@ -220,27 +244,32 @@ void sanitize_env (void)
 	char **cur;
 	char **move;

-	for (cur = envp; *cur; cur++) {
-		for (bad = forbid; *bad; bad++) {
+	for (cur = envp; NULL != *cur; cur++) {
+		for (bad = forbid; NULL != *bad; bad++) {
 			if (strncmp (*cur, *bad, strlen (*bad)) == 0) {
-				for (move = cur; *move; move++)
+				for (move = cur; NULL != *move; move++) {
 					*move = *(move + 1);
+				}
 				cur--;
 				break;
 			}
 		}
 	}

-	for (cur = envp; *cur; cur++) {
-		for (bad = noslash; *bad; bad++) {
-			if (strncmp (*cur, *bad, strlen (*bad)) != 0)
+	for (cur = envp; NULL != *cur; cur++) {
+		for (bad = noslash; NULL != *bad; bad++) {
+			if (strncmp (*cur, *bad, strlen (*bad)) != 0) {
 				continue;
-			if (!strchr (*cur, '/'))
+			}
+			if (strchr (*cur, '/') == NULL) {
 				continue;	/* OK */
-			for (move = cur; *move; move++)
+			}
+			for (move = cur; NULL != *move; move++) {
 				*move = *(move + 1);
+			}
 			cur--;
 			break;
 		}
 	}
 }
+
--- a/libmisc/failure.c
+++ b/libmisc/failure.c
@@ -2,6 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2002 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2008 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -35,6 +36,7 @@

 #include <fcntl.h>
 #include <stdio.h>
+#include <unistd.h>
 #include "defines.h"
 #include "faillog.h"
 #include "getdef.h"
@@ -49,13 +51,23 @@
 void failure (uid_t uid, const char *tty, struct faillog *fl)
 {
 	int fd;
+	off_t offset_uid = (off_t) (sizeof *fl) * uid;

 	/*
 	 * Don't do anything if failure logging isn't set up.
 	 */

-	if ((fd = open (FAILLOG_FILE, O_RDWR)) < 0)
+	if (access (FAILLOG_FILE, F_OK) != 0) {
 		return;
+	}
+
+	fd = open (FAILLOG_FILE, O_RDWR);
+	if (fd < 0) {
+		SYSLOG ((LOG_WARN,
+		         "Can't write faillog entry for UID %lu in %s.",
+		         (unsigned long) uid, FAILLOG_FILE));
+		return;
+	}

 	/*
 	 * The file is indexed by UID value meaning that shared UID's
@@ -63,9 +75,17 @@ void failure (uid_t uid, const char *tty, struct faillog *fl)
 	 * share just about everything else ...
 	 */

-	lseek (fd, (off_t) (sizeof *fl) * uid, SEEK_SET);
-	if (read (fd, (char *) fl, sizeof *fl) != sizeof *fl)
+	if (   (lseek (fd, offset_uid, SEEK_SET) != offset_uid)
+	    || (read (fd, (char *) fl, sizeof *fl) != (ssize_t) sizeof *fl)) {
+		/* This is not necessarily a failure. The file is
+		 * initially zero length.
+		 *
+		 * If lseek() or read() failed for any other reason, this
+		 * might reset the counter. But the new failure will be
+		 * logged.
+		 */
 		memzero (fl, sizeof *fl);
+	}

 	/*
 	 * Update the record.  We increment the failure count to log the
@@ -74,11 +94,12 @@ void failure (uid_t uid, const char *tty, struct faillog *fl)
 	 * updated as well.
 	 */

-	if (fl->fail_cnt + 1 > 0)
+	if (fl->fail_cnt + 1 > 0) {
 		fl->fail_cnt++;
+	}

 	strncpy (fl->fail_line, tty, sizeof fl->fail_line);
-	time (&fl->fail_time);
+	(void) time (&fl->fail_time);

 	/*
 	 * Seek back to the correct position in the file and write the
@@ -87,26 +108,34 @@ void failure (uid_t uid, const char *tty, struct faillog *fl)
 	 * seem that great.
 	 */

-	lseek (fd, (off_t) (sizeof *fl) * uid, SEEK_SET);
-	write (fd, (char *) fl, sizeof *fl);
-	close (fd);
+	if (   (lseek (fd, offset_uid, SEEK_SET) != offset_uid)
+	    || (write (fd, (char *) fl, sizeof *fl) != (ssize_t) sizeof *fl)
+	    || (close (fd) != 0)) {
+		SYSLOG ((LOG_WARN,
+		         "Can't write faillog entry for UID %lu in %s.",
+		         (unsigned long) uid, FAILLOG_FILE));
+		(void) close (fd);
+	}
 }

-static int too_many_failures (const struct faillog *fl)
+static bool too_many_failures (const struct faillog *fl)
 {
 	time_t now;

-	if (fl->fail_max == 0 || fl->fail_cnt < fl->fail_max)
-		return 0;
+	if ((0 == fl->fail_max) || (fl->fail_cnt < fl->fail_max)) {
+		return false;
+	}

-	if (fl->fail_locktime == 0)
-		return 1;	/* locked until reset manually */
+	if (0 == fl->fail_locktime) {
+		return true;	/* locked until reset manually */
+	}

-	time (&now);
-	if (fl->fail_time + fl->fail_locktime < now)
-		return 0;	/* enough time since last failure */
+	(void) time (&now);
+	if ((fl->fail_time + fl->fail_locktime) < now) {
+		return false;	/* enough time since last failure */
+	}

-	return 1;
+	return true;
 }

 /*
@@ -114,21 +143,35 @@ static int too_many_failures (const struct faillog *fl)
 *
 *	failcheck() is called AFTER the password has been validated.  If the
 *	account has been "attacked" with too many login failures, failcheck()
- *	returns FALSE to indicate that the login should be denied even though
+ *	returns 0 to indicate that the login should be denied even though
 *	the password is valid.
+ *
+ *	failed indicates if the login failed AFTER the password has been
+ *	       validated.
 */

-int failcheck (uid_t uid, struct faillog *fl, int failed)
+int failcheck (uid_t uid, struct faillog *fl, bool failed)
 {
 	int fd;
 	struct faillog fail;
+	off_t offset_uid = (off_t) (sizeof *fl) * uid;

 	/*
 	 * Suppress the check if the log file isn't there.
 	 */

-	if ((fd = open (FAILLOG_FILE, O_RDWR)) < 0)
+	if (access (FAILLOG_FILE, F_OK) != 0) {
 		return 1;
+	}
+
+	fd = open (FAILLOG_FILE, failed?O_RDONLY:O_RDWR);
+	if (fd < 0) {
+		SYSLOG ((LOG_WARN,
+		         "Can't open the faillog file (%s) to check UID %lu. "
+		         "User access authorized.",
+		         FAILLOG_FILE, (unsigned long) uid));
+		return 1;
+	}

 	/*
 	 * Get the record from the file and determine if the user has
@@ -142,14 +185,14 @@ int failcheck (uid_t uid, struct faillog *fl, int failed)
 	 * no need to reset the count.
 	 */

-	lseek (fd, (off_t) (sizeof *fl) * uid, SEEK_SET);
-	if (read (fd, (char *) fl, sizeof *fl) != sizeof *fl) {
-		close (fd);
+	if (   (lseek (fd, offset_uid, SEEK_SET) != offset_uid)
+	    || (read (fd, (char *) fl, sizeof *fl) != (ssize_t) sizeof *fl)) {
+		(void) close (fd);
 		return 1;
 	}

 	if (too_many_failures (fl)) {
-		close (fd);
+		(void) close (fd);
 		return 0;
 	}

@@ -164,10 +207,18 @@ int failcheck (uid_t uid, struct faillog *fl, int failed)
 		fail = *fl;
 		fail.fail_cnt = 0;

-		lseek (fd, (off_t) sizeof fail * uid, SEEK_SET);
-		write (fd, (char *) &fail, sizeof fail);
+		if (   (lseek (fd, offset_uid, SEEK_SET) != offset_uid)
+		    || (write (fd, (const void *) &fail, sizeof fail) != (ssize_t) sizeof fail)
+		    || (close (fd) != 0)) {
+			SYSLOG ((LOG_WARN,
+			         "Can't reset faillog entry for UID %lu in %s.",
+			         (unsigned long) uid, FAILLOG_FILE));
+			(void) close (fd);
+		}
+	} else {
+		(void) close (fd);
 	}
-	close (fd);
+
 	return 1;
 }

@@ -190,17 +241,18 @@ void failprint (const struct faillog *fail)
 #endif
 	time_t NOW;

-	if (fail->fail_cnt == 0)
+	if (0 == fail->fail_cnt) {
 		return;
+	}

 	tp = localtime (&(fail->fail_time));
-	time (&NOW);
+	(void) time (&NOW);

 #if HAVE_STRFTIME
 	/*
 	 * Print all information we have.
 	 */
-	strftime (lasttimeb, sizeof lasttimeb, "%c", tp);
+	(void) strftime (lasttimeb, sizeof lasttimeb, "%c", tp);
 #else

 	/*
@@ -210,38 +262,43 @@ void failprint (const struct faillog *fail)
 	lasttime = asctime (tp);
 	lasttime[24] = '\0';

-	if (NOW - fail->fail_time < YEAR)
+	if ((NOW - fail->fail_time) < YEAR) {
 		lasttime[19] = '\0';
-	if (NOW - fail->fail_time < DAY)
+	}
+	if ((NOW - fail->fail_time) < DAY) {
 		lasttime = lasttime + 11;
+	}

-	if (*lasttime == ' ')
+	if (' ' == *lasttime) {
 		lasttime++;
+	}
 #endif
-	printf (ngettext ("%d failure since last login.\n"
-			  "Last was %s on %s.\n",
-			  "%d failures since last login.\n"
-			  "Last was %s on %s.\n",
-			  fail->fail_cnt),
-		fail->fail_cnt, lasttime, fail->fail_line);
+	/*@-formatconst@*/
+	(void) printf (ngettext ("%d failure since last login.\n"
+	                         "Last was %s on %s.\n",
+	                         "%d failures since last login.\n"
+	                         "Last was %s on %s.\n",
+	                         (unsigned long) fail->fail_cnt),
+	               fail->fail_cnt, lasttime, fail->fail_line);
+	/*@=formatconst@*/
 }

 /*
- * failtmp - update the cummulative failure log
+ * failtmp - update the cumulative failure log
 *
 *	failtmp updates the (struct utmp) formatted failure log which
 *	maintains a record of all login failures.
 */

-void failtmp (
-#ifdef HAVE_UTMPX_H
+void failtmp (const char *username,
+#ifdef USE_UTMPX
 		     const struct utmpx *failent
-#else
+#else				/* !USE_UTMPX */
 		     const struct utmp *failent
-#endif
+#endif				/* !USE_UTMPX */
    )
 {
-	char *ftmp;
+	const char *ftmp;
 	int fd;

 	/*
@@ -249,21 +306,38 @@ void failtmp (
 	 * in login.defs, don't do this.
 	 */

-	if (!(ftmp = getdef_str ("FTMP_FILE")))
+	ftmp = getdef_str ("FTMP_FILE");
+	if (NULL == ftmp) {
 		return;
+	}

 	/*
 	 * Open the file for append.  It must already exist for this
 	 * feature to be used.
 	 */

-	if ((fd = open (ftmp, O_WRONLY | O_APPEND)) == -1)
+	if (access (ftmp, F_OK) != 0) {
 		return;
+	}
+
+	fd = open (ftmp, O_WRONLY | O_APPEND);
+	if (-1 == fd) {
+		SYSLOG ((LOG_WARN,
+		         "Can't append failure of user %s to %s.",
+		         username, ftmp));
+		return;
+	}

 	/*
-	 * Output the new failure record and close the log file.
+	 * Append the new failure record and close the log file.
 	 */

-	write (fd, (const char *) failent, sizeof *failent);
-	close (fd);
+	if (   (write (fd, (const void *) failent, sizeof *failent) != (ssize_t) sizeof *failent)
+	    || (close (fd) != 0)) {
+		SYSLOG ((LOG_WARN,
+		         "Can't append failure of user %s to %s.",
+		         username, ftmp));
+		(void) close (fd);
+	}
 }
+
--- a/libmisc/failure.h
+++ b/libmisc/failure.h
@@ -2,6 +2,7 @@
 * Copyright (c) 1990 - 1994, Julianne Frances Haugh
 * Copyright (c) 1997 - 2000, Marek Michałkiewicz
 * Copyright (c) 2005       , Tomasz Kłoczko
+ * Copyright (c) 2008 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -35,11 +36,11 @@

 #include "defines.h"
 #include "faillog.h"
-#ifdef HAVE_UTMPX_H
+#ifdef USE_UTMPX
 #include <utmpx.h>
-#else
+#else					/* !USE_UTMPX */
 #include <utmp.h>
-#endif
+#endif					/* !USE_UTMPX */

 /*
 * failure - make failure entry
@@ -57,7 +58,7 @@ extern void failure (uid_t, const char *, struct faillog *);
 *	returns FALSE to indicate that the login should be denied even though
 *	the password is valid.
 */
-extern int failcheck (uid_t, struct faillog *, int);
+extern int failcheck (uid_t uid, struct faillog *fl, bool failed);

 /*
 * failprint - print line of failure information
@@ -73,11 +74,11 @@ extern void failprint (const struct faillog *);
 *	failtmp updates the (struct utmp) formatted failure log which
 *	maintains a record of all login failures.
 */
-#ifdef HAVE_UTMPX_H
-extern void failtmp (const struct utmpx *);
-#else
-extern void failtmp (const struct utmp *);
-#endif
+#ifdef USE_UTMPX
+extern void failtmp (const char *username, const struct utmpx *);
+#else				/* !USE_UTMPX */
+extern void failtmp (const char *username, const struct utmp *);
+#endif				/* !USE_UTMPX */

 #endif

--- a/libmisc/find_new_gid.c
+++ b/libmisc/find_new_gid.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 1991 - 1994, Julianne Frances Haugh
+ * Copyright (c) 2008 - 2011, Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "prototypes.h"
+#include "groupio.h"
+#include "getdef.h"
+
+/*
+ * find_new_gid - Find a new unused GID.
+ *
+ * If successful, find_new_gid provides an unused group ID in the
+ * [GID_MIN:GID_MAX] range.
+ * This ID should be higher than all the used GID, but if not possible,
+ * the lowest unused ID in the range will be returned.
+ * 
+ * Return 0 on success, -1 if no unused GIDs are available.
+ */
+int find_new_gid (bool sys_group,
+                  gid_t *gid,
+                  /*@null@*/gid_t const *preferred_gid)
+{
+	const struct group *grp;
+	gid_t gid_min, gid_max, group_id;
+	bool *used_gids;
+
+	assert (gid != NULL);
+
+	if (!sys_group) {
+		gid_min = (gid_t) getdef_ulong ("GID_MIN", 1000UL);
+		gid_max = (gid_t) getdef_ulong ("GID_MAX", 60000UL);
+		if (gid_max < gid_min) {
+			(void) fprintf (stderr,
+			                _("%s: Invalid configuration: GID_MIN (%lu), GID_MAX (%lu)\n"),
+			                Prog, (unsigned long) gid_min, (unsigned long) gid_max);
+			return -1;
+		}
+	} else {
+		gid_min = (gid_t) getdef_ulong ("SYS_GID_MIN", 101UL);
+		gid_max = (gid_t) getdef_ulong ("GID_MIN", 1000UL) - 1;
+		gid_max = (gid_t) getdef_ulong ("SYS_GID_MAX", (unsigned long) gid_max);
+		if (gid_max < gid_min) {
+			(void) fprintf (stderr,
+			                _("%s: Invalid configuration: SYS_GID_MIN (%lu), GID_MIN (%lu), SYS_GID_MAX (%lu)\n"),
+			                Prog, (unsigned long) gid_min, getdef_ulong ("GID_MIN", 1000UL), (unsigned long) gid_max);
+			return -1;
+		}
+	}
+	used_gids = malloc (sizeof (bool) * (gid_max +1));
+	if (NULL == used_gids) {
+		fprintf (stderr,
+		         _("%s: failed to allocate memory: %s\n"),
+		         Prog, strerror (errno));
+		return -1;
+	}
+	memset (used_gids, false, sizeof (bool) * (gid_max + 1));
+
+	if (   (NULL != preferred_gid)
+	    && (*preferred_gid >= gid_min)
+	    && (*preferred_gid <= gid_max)
+	    /* Check if the user exists according to NSS */
+	    && (getgrgid (*preferred_gid) == NULL)
+	    /* Check also the local database in case of uncommitted
+	     * changes */
+	    && (gr_locate_gid (*preferred_gid) == NULL)) {
+		*gid = *preferred_gid;
+		free (used_gids);
+		return 0;
+	}
+
+
+	/*
+	 * Search the entire group file,
+	 * looking for the largest unused value.
+	 *
+	 * We check the list of groups according to NSS (setgrent/getgrent),
+	 * but we also check the local database (gr_rewind/gr_next) in case
+	 * some groups were created but the changes were not committed yet.
+	 */
+	if (sys_group) {
+		gid_t id;
+		/* setgrent / getgrent / endgrent can be very slow with
+		 * LDAP configurations (and many accounts).
+		 * Since there is a limited amount of IDs to be tested
+		 * for system accounts, we just check the existence
+		 * of IDs with getgrgid.
+		 */
+		group_id = gid_max;
+		for (id = gid_max; id >= gid_min; id--) {
+			if (getgrgid (id) != NULL) {
+				group_id = id - 1;
+				used_gids[id] = true;
+			}
+		}
+
+		(void) gr_rewind ();
+		while ((grp = gr_next ()) != NULL) {
+			if ((grp->gr_gid <= group_id) && (grp->gr_gid >= gid_min)) {
+				group_id = grp->gr_gid - 1;
+			}
+			/* create index of used GIDs */
+			if (grp->gr_gid <= gid_max) {
+				used_gids[grp->gr_gid] = true;
+			}
+		}
+	} else {
+		group_id = gid_min;
+		setgrent ();
+		while ((grp = getgrent ()) != NULL) {
+			if ((grp->gr_gid >= group_id) && (grp->gr_gid <= gid_max)) {
+				group_id = grp->gr_gid + 1;
+			}
+			/* create index of used GIDs */
+			if (grp->gr_gid <= gid_max) {
+				used_gids[grp->gr_gid] = true;
+			}
+		}
+		endgrent ();
+
+		(void) gr_rewind ();
+		while ((grp = gr_next ()) != NULL) {
+			if ((grp->gr_gid >= group_id) && (grp->gr_gid <= gid_max)) {
+				group_id = grp->gr_gid + 1;
+			}
+			/* create index of used GIDs */
+			if (grp->gr_gid <= gid_max) {
+				used_gids[grp->gr_gid] = true;
+			}
+		}
+	}
+
+	/*
+	 * If a group (resp. system group) with GID equal to GID_MAX (resp.
+	 * GID_MIN) exists, the above algorithm will give us GID_MAX+1
+	 * (resp. GID_MIN-1) even if not unique. Search for the first free
+	 * GID starting with GID_MIN (resp. GID_MAX).
+	 */
+	if (sys_group) {
+		if (group_id < gid_min) {
+			for (group_id = gid_max; group_id >= gid_min; group_id--) {
+				if (false == used_gids[group_id]) {
+					break;
+				}
+			}
+			if (group_id < gid_min) {
+				fprintf (stderr,
+				         _("%s: Can't get unique system GID (no more available GIDs)\n"),
+				         Prog);
+				SYSLOG ((LOG_WARN,
+				         "no more available GID on the system"));
+				free (used_gids);
+				return -1;
+			}
+		}
+	} else {
+		if (group_id > gid_max) {
+			for (group_id = gid_min; group_id <= gid_max; group_id++) {
+				if (false == used_gids[group_id]) {
+					break;
+				}
+			}
+			if (group_id > gid_max) {
+				fprintf (stderr,
+				         _("%s: Can't get unique GID (no more available GIDs)\n"),
+				         Prog);
+				SYSLOG ((LOG_WARN, "no more available GID on the system"));
+				free (used_gids);
+				return -1;
+			}
+		}
+	}
+
+	free (used_gids);
+	*gid = group_id;
+	return 0;
+}
+
--- a/libmisc/find_new_ids.c
+++ b/libmisc/find_new_ids.c
@@ -1,205 +0,0 @@
-/*
- * Copyright (c) 1991 - 1994, Julianne Frances Haugh
- * Copyright (c) 2008       , Nicolas François
- * 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.
- * 3. The name of the copyright holders or contributors may not be used to
- *    endorse or promote products derived from this software without
- *    specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
- * HOLDERS 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.
- */
-
-#include <config.h>
-
-#include <assert.h>
-#include <stdio.h>
-
-#include "prototypes.h"
-#include "pwio.h"
-#include "groupio.h"
-#include "getdef.h"
-
-/*
- * find_new_uid - Find a new unused UID.
- *
- * If successful, find_new_uid provides an unused user ID in the
- * [UID_MIN:UID_MAX] range.
- * This ID should be higher than all the used UID, but if not possible,
- * the lowest unused ID in the range will be returned.
- * 
- * Return 0 on success, -1 if no unused UIDs are available.
- */
-int find_new_uid (int sys_user, uid_t *uid, uid_t const *preferred_uid)
-{
-	const struct passwd *pwd;
-	uid_t uid_min, uid_max, user_id;
-
-	assert (uid != NULL);
-
-	if (sys_user == 0) {
-		uid_min = getdef_unum ("UID_MIN", 1000);
-		uid_max = getdef_unum ("UID_MAX", 60000);
-	} else {
-		uid_min = getdef_unum ("SYS_UID_MIN", 1);
-		uid_max = getdef_unum ("UID_MIN", 1000) - 1;
-		uid_max = getdef_unum ("SYS_UID_MAX", uid_max);
-	}
-
-	if (   (NULL != preferred_uid)
-	    && (*preferred_uid >= uid_min)
-	    && (*preferred_uid <= uid_max)
-	    /* Check if the user exists according to NSS */
-	    && (getpwuid (*preferred_uid) == NULL)
-	    /* Check also the local database in case of uncommitted
-	     * changes */
-	    && (pw_locate_uid (*preferred_uid) == NULL)) {
-		*uid = *preferred_uid;
-		return 0;
-	}
-
-
-	user_id = uid_min;
-
-	/*
-	 * Search the entire password file,
-	 * looking for the largest unused value.
-	 *
-	 * We check the list of users according to NSS (setpwent/getpwent),
-	 * but we also check the local database (pw_rewind/pw_next) in case
-	 * some users were created but the changes were not committed yet.
-	 */
-	setpwent ();
-	pw_rewind ();
-	while (   ((pwd = getpwent ()) != NULL)
-	       || ((pwd = pw_next ()) != NULL)) {
-		if ((pwd->pw_uid >= user_id) && (pwd->pw_uid <= uid_max)) {
-			user_id = pwd->pw_uid + 1;
-		}
-	}
-	endpwent ();
-
-	/*
-	 * If a user with UID equal to UID_MAX exists, the above algorithm
-	 * will give us UID_MAX+1 even if not unique. Search for the first
-	 * free UID starting with UID_MIN (it's O(n*n) but can be avoided
-	 * by not having users with UID equal to UID_MAX).  --marekm
-	 */
-	if (user_id == uid_max + 1) {
-		for (user_id = uid_min; user_id < uid_max; user_id++) {
-			/* local, no need for xgetpwuid */
-			if (   (getpwuid (user_id) == NULL)
-			    && (pw_locate_uid (user_id) == NULL)) {
-				break;
-			}
-		}
-		if (user_id == uid_max) {
-			fputs (_("Can't get unique UID (no more available UIDs)\n"), stderr);
-			return -1;
-		}
-	}
-
-	*uid = user_id;
-	return 0;
-}
-
-/*
- * find_new_gid - Find a new unused GID.
- *
- * If successful, find_new_gid provides an unused group ID in the
- * [GID_MIN:GID_MAX] range.
- * This ID should be higher than all the used GID, but if not possible,
- * the lowest unused ID in the range will be returned.
- * 
- * Return 0 on success, -1 if no unused GIDs are available.
- */
-int find_new_gid (int sys_group, gid_t *gid, gid_t const *preferred_gid)
-{
-	const struct group *grp;
-	gid_t gid_min, gid_max, group_id;
-
-	assert (gid != NULL);
-
-	if (sys_group == 0) {
-		gid_min = getdef_unum ("GID_MIN", 1000);
-		gid_max = getdef_unum ("GID_MAX", 60000);
-	} else {
-		gid_min = getdef_unum ("SYS_GID_MIN", 1);
-		gid_max = getdef_unum ("GID_MIN", 1000) - 1;
-		gid_max = getdef_unum ("SYS_GID_MAX", gid_max);
-	}
-
-	if (   (NULL != preferred_gid)
-	    && (*preferred_gid >= gid_min)
-	    && (*preferred_gid <= gid_max)
-	    /* Check if the user exists according to NSS */
-	    && (getgrgid (*preferred_gid) == NULL)
-	    /* Check also the local database in case of uncommitted
-	     * changes */
-	    && (gr_locate_gid (*preferred_gid) == NULL)) {
-		*gid = *preferred_gid;
-		return 0;
-	}
-
-	group_id = gid_min;
-
-	/*
-	 * Search the entire group file,
-	 * looking for the largest unused value.
-	 *
-	 * We check the list of users according to NSS (setpwent/getpwent),
-	 * but we also check the local database (pw_rewind/pw_next) in case
-	 * some groups were created but the changes were not committed yet.
-	 */
-	setgrent ();
-	gr_rewind ();
-	while (   ((grp = getgrent ()) != NULL)
-	       || ((grp = gr_next ()) != NULL)) {
-		if ((grp->gr_gid >= group_id) && (grp->gr_gid <= gid_max)) {
-			group_id = grp->gr_gid + 1;
-		}
-	}
-	endgrent ();
-
-	/*
-	 * If a group with GID equal to GID_MAX exists, the above algorithm
-	 * will give us GID_MAX+1 even if not unique. Search for the first
-	 * free GID starting with GID_MIN (it's O(n*n) but can be avoided
-	 * by not having users with GID equal to GID_MAX).  --marekm
-	 */
-	if (group_id == gid_max + 1) {
-		for (group_id = gid_min; group_id < gid_max; group_id++) {
-			/* local, no need for xgetgrgid */
-			if (   (getgrgid (group_id) == NULL)
-			    && (gr_locate_gid (group_id) == NULL)) {
-				break;
-			}
-		}
-		if (group_id == gid_max) {
-			fputs (_("Can't get unique GID (no more available GIDs)\n"), stderr);
-			return -1;
-		}
-	}
-
-	*gid = group_id;
-	return 0;
-}
-
--- a/libmisc/find_new_sub_gids.c
+++ b/libmisc/find_new_sub_gids.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2012 Eric Biederman
+ *
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ifdef ENABLE_SUBIDS
+
+#include <assert.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "prototypes.h"
+#include "subordinateio.h"
+#include "getdef.h"
+
+/*
+ * find_new_sub_gids - Find a new unused range of GIDs.
+ *
+ * If successful, find_new_sub_gids provides a range of unused
+ * user IDs in the [SUB_GID_MIN:SUB_GID_MAX] range.
+ * 
+ * Return 0 on success, -1 if no unused GIDs are available.
+ */
+int find_new_sub_gids (const char *owner,
+		       gid_t *range_start, unsigned long *range_count)
+{
+	unsigned long min, max;
+	unsigned long count;
+	gid_t start;
+
+	assert (range_start != NULL);
+	assert (range_count != NULL);
+
+	min = getdef_ulong ("SUB_GID_MIN", 100000UL);
+	max = getdef_ulong ("SUB_GID_MAX", 600100000UL);
+	count = getdef_ulong ("SUB_GID_COUNT", 10000);
+
+	if (min > max || count >= max || (min + count - 1) > max) {
+		(void) fprintf (stderr,
+				_("%s: Invalid configuration: SUB_GID_MIN (%lu),"
+				  " SUB_GID_MAX (%lu), SUB_GID_COUNT (%lu)\n"),
+			Prog, min, max, count);
+		return -1;
+	}
+
+	start = sub_gid_find_free_range(min, max, count);
+	if (start == (gid_t)-1) {
+		fprintf (stderr,
+		         _("%s: Can't get unique subordinate GID range\n"),
+		         Prog);
+		SYSLOG ((LOG_WARN, "no more available subordinate GIDs on the system"));
+		return -1;
+	}
+	*range_start = start;
+	*range_count = count;
+	return 0;
+}
+#else				/* !ENABLE_SUBIDS */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* !ENABLE_SUBIDS */
+
--- a/libmisc/find_new_sub_uids.c
+++ b/libmisc/find_new_sub_uids.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2012 Eric Biederman
+ *
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ifdef ENABLE_SUBIDS
+
+#include <assert.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "prototypes.h"
+#include "subordinateio.h"
+#include "getdef.h"
+
+/*
+ * find_new_sub_uids - Find a new unused range of UIDs.
+ *
+ * If successful, find_new_sub_uids provides a range of unused
+ * user IDs in the [SUB_UID_MIN:SUB_UID_MAX] range.
+ * 
+ * Return 0 on success, -1 if no unused UIDs are available.
+ */
+int find_new_sub_uids (const char *owner,
+		       uid_t *range_start, unsigned long *range_count)
+{
+	unsigned long min, max;
+	unsigned long count;
+	uid_t start;
+
+	assert (range_start != NULL);
+	assert (range_count != NULL);
+
+	min = getdef_ulong ("SUB_UID_MIN", 100000UL);
+	max = getdef_ulong ("SUB_UID_MAX", 600100000UL);
+	count = getdef_ulong ("SUB_UID_COUNT", 10000);
+
+	if (min > max || count >= max || (min + count - 1) > max) {
+		(void) fprintf (stderr,
+				_("%s: Invalid configuration: SUB_UID_MIN (%lu),"
+				  " SUB_UID_MAX (%lu), SUB_UID_COUNT (%lu)\n"),
+			Prog, min, max, count);
+		return -1;
+	}
+
+	start = sub_uid_find_free_range(min, max, count);
+	if (start == (uid_t)-1) {
+		fprintf (stderr,
+		         _("%s: Can't get unique subordinate UID range\n"),
+		         Prog);
+		SYSLOG ((LOG_WARN, "no more available subordinate UIDs on the system"));
+		return -1;
+	}
+	*range_start = start;
+	*range_count = count;
+	return 0;
+}
+#else				/* !ENABLE_SUBIDS */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* !ENABLE_SUBIDS */
+
--- a/libmisc/find_new_uid.c
+++ b/libmisc/find_new_uid.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 1991 - 1994, Julianne Frances Haugh
+ * Copyright (c) 2008 - 2011, Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include "prototypes.h"
+#include "pwio.h"
+#include "getdef.h"
+
+/*
+ * find_new_uid - Find a new unused UID.
+ *
+ * If successful, find_new_uid provides an unused user ID in the
+ * [UID_MIN:UID_MAX] range.
+ * This ID should be higher than all the used UID, but if not possible,
+ * the lowest unused ID in the range will be returned.
+ * 
+ * Return 0 on success, -1 if no unused UIDs are available.
+ */
+int find_new_uid (bool sys_user,
+                  uid_t *uid,
+                  /*@null@*/uid_t const *preferred_uid)
+{
+	const struct passwd *pwd;
+	uid_t uid_min, uid_max, user_id;
+	bool *used_uids;
+
+	assert (uid != NULL);
+
+	if (!sys_user) {
+		uid_min = (uid_t) getdef_ulong ("UID_MIN", 1000UL);
+		uid_max = (uid_t) getdef_ulong ("UID_MAX", 60000UL);
+		if (uid_max < uid_min) {
+			(void) fprintf (stderr,
+			                _("%s: Invalid configuration: UID_MIN (%lu), UID_MAX (%lu)\n"),
+			                Prog, (unsigned long) uid_min, (unsigned long) uid_max);
+			return -1;
+		}
+	} else {
+		uid_min = (uid_t) getdef_ulong ("SYS_UID_MIN", 101UL);
+		uid_max = (uid_t) getdef_ulong ("UID_MIN", 1000UL) - 1;
+		uid_max = (uid_t) getdef_ulong ("SYS_UID_MAX", (unsigned long) uid_max);
+		if (uid_max < uid_min) {
+			(void) fprintf (stderr,
+			                _("%s: Invalid configuration: SYS_UID_MIN (%lu), UID_MIN (%lu), SYS_UID_MAX (%lu)\n"),
+			                Prog, (unsigned long) uid_min, getdef_ulong ("UID_MIN", 1000UL), (unsigned long) uid_max);
+			return -1;
+		}
+	}
+	used_uids = malloc (sizeof (bool) * (uid_max +1));
+	if (NULL == used_uids) {
+		fprintf (stderr,
+		         _("%s: failed to allocate memory: %s\n"),
+		         Prog, strerror (errno));
+		return -1;
+	}
+	memset (used_uids, false, sizeof (bool) * (uid_max + 1));
+
+	if (   (NULL != preferred_uid)
+	    && (*preferred_uid >= uid_min)
+	    && (*preferred_uid <= uid_max)
+	    /* Check if the user exists according to NSS */
+	    && (getpwuid (*preferred_uid) == NULL)
+	    /* Check also the local database in case of uncommitted
+	     * changes */
+	    && (pw_locate_uid (*preferred_uid) == NULL)) {
+		*uid = *preferred_uid;
+		free (used_uids);
+		return 0;
+	}
+
+
+	/*
+	 * Search the entire password file,
+	 * looking for the largest unused value.
+	 *
+	 * We check the list of users according to NSS (setpwent/getpwent),
+	 * but we also check the local database (pw_rewind/pw_next) in case
+	 * some users were created but the changes were not committed yet.
+	 */
+	if (sys_user) {
+		uid_t id;
+		/* setpwent / getpwent / endpwent can be very slow with
+		 * LDAP configurations (and many accounts).
+		 * Since there is a limited amount of IDs to be tested
+		 * for system accounts, we just check the existence
+		 * of IDs with getpwuid.
+		 */
+		user_id = uid_max;
+		for (id = uid_max; id >= uid_min; id--) {
+			if (getpwuid (id) != NULL) {
+				user_id = id - 1;
+				used_uids[id] = true;
+			}
+		}
+
+		(void) pw_rewind ();
+		while ((pwd = pw_next ()) != NULL) {
+			if ((pwd->pw_uid <= user_id) && (pwd->pw_uid >= uid_min)) {
+				user_id = pwd->pw_uid - 1;
+			}
+			/* create index of used UIDs */
+			if (pwd->pw_uid <= uid_max) {
+				used_uids[pwd->pw_uid] = true;
+			}
+		}
+	} else {
+		user_id = uid_min;
+		setpwent ();
+		while ((pwd = getpwent ()) != NULL) {
+			if ((pwd->pw_uid >= user_id) && (pwd->pw_uid <= uid_max)) {
+				user_id = pwd->pw_uid + 1;
+			}
+			/* create index of used UIDs */
+			if (pwd->pw_uid <= uid_max) {
+				used_uids[pwd->pw_uid] = true;
+			}
+		}
+		endpwent ();
+
+		(void) pw_rewind ();
+		while ((pwd = pw_next ()) != NULL) {
+			if ((pwd->pw_uid >= user_id) && (pwd->pw_uid <= uid_max)) {
+				user_id = pwd->pw_uid + 1;
+			}
+			/* create index of used UIDs */
+			if (pwd->pw_uid <= uid_max) {
+				used_uids[pwd->pw_uid] = true;
+			}
+		}
+	}
+
+	/*
+	 * If a user (resp. system user) with UID equal to UID_MAX (resp.
+	 * UID_MIN) exists, the above algorithm will give us UID_MAX+1
+	 * (resp. UID_MIN-1) even if not unique. Search for the first free
+	 * UID starting with UID_MIN (resp. UID_MAX).
+	 */
+	if (sys_user) {
+		if (user_id < uid_min) {
+			for (user_id = uid_max; user_id >= uid_min; user_id--) {
+				if (false == used_uids[user_id]) {
+					break;
+				}
+			}
+			if (user_id < uid_min ) {
+				fprintf (stderr,
+				         _("%s: Can't get unique system UID (no more available UIDs)\n"),
+				         Prog);
+				SYSLOG ((LOG_WARN,
+				         "no more available UID on the system"));
+				free (used_uids);
+				return -1;
+			}
+		}
+	} else {
+		if (user_id > uid_max) {
+			for (user_id = uid_min; user_id <= uid_max; user_id++) {
+				if (false == used_uids[user_id]) {
+					break;
+				}
+			}
+			if (user_id > uid_max) {
+				fprintf (stderr,
+				         _("%s: Can't get unique UID (no more available UIDs)\n"),
+				         Prog);
+				SYSLOG ((LOG_WARN, "no more available UID on the system"));
+				free (used_uids);
+				return -1;
+			}
+		}
+	}
+
+	free (used_uids);
+	*uid = user_id;
+	return 0;
+}
+
--- a/libmisc/getdate.h
+++ b/libmisc/getdate.h
@@ -35,5 +35,5 @@
 #include <config.h>
 #include "defines.h"

-time_t get_date (const char *, const time_t *);
+time_t get_date (const char *p, /*@null@*/const time_t *now);
 #endif
--- a/libmisc/getdate.y
+++ b/libmisc/getdate.y
@@ -395,7 +395,7 @@ relunit	: tUNUMBER tYEAR_UNIT {

 number	: tUNUMBER
          {
-	    if (yyHaveTime && yyHaveDate && !yyHaveRel)
+	    if ((yyHaveTime != 0) && (yyHaveDate != 0) && (yyHaveRel == 0))
 	      yyYear = $1;
 	    else
 	      {
@@ -647,10 +647,10 @@ static int LookupWord (char *buff)
  register char *q;
  register const TABLE *tp;
  int i;
-  int abbrev;
+  bool abbrev;

  /* Make it lowercase. */
-  for (p = buff; *p; p++)
+  for (p = buff; '\0' != *p; p++)
    if (ISUPPER (*p))
      *p = tolower (*p);

@@ -667,14 +667,14 @@ static int LookupWord (char *buff)

  /* See if we have an abbreviation for a month. */
  if (strlen (buff) == 3)
-    abbrev = 1;
+    abbrev = true;
  else if (strlen (buff) == 4 && buff[3] == '.')
    {
-      abbrev = 1;
+      abbrev = true;
      buff[3] = '\0';
    }
  else
-    abbrev = 0;
+    abbrev = false;

  for (tp = MonthDayTable; tp->name; tp++)
    {
@@ -743,14 +743,14 @@ static int LookupWord (char *buff)
    }

  /* Drop out any periods and try the timezone table again. */
-  for (i = 0, p = q = buff; *q; q++)
+  for (i = 0, p = q = buff; '\0' != *q; q++)
    if (*q != '.')
      *p++ = *q;
    else
      i++;
  *p = '\0';
-  if (i)
-    for (tp = TimezoneTable; tp->name; tp++)
+  if (0 != i)
+    for (tp = TimezoneTable; NULL != tp->name; tp++)
      if (strcmp (buff, tp->name) == 0)
 	{
 	  yylval.Number = tp->value;
@@ -790,7 +790,7 @@ yylex (void)
 	  yyInput--;
 	  if (sign < 0)
 	    yylval.Number = -yylval.Number;
-	  return sign ? tSNUMBER : tUNUMBER;
+	  return (0 != sign) ? tSNUMBER : tUNUMBER;
 	}
      if (ISALPHA (c))
 	{
@@ -874,7 +874,8 @@ time_t get_date (const char *p, const time_t *now)
  tm.tm_year = ToYear (yyYear) - TM_YEAR_ORIGIN + yyRelYear;
  tm.tm_mon = yyMonth - 1 + yyRelMonth;
  tm.tm_mday = yyDay + yyRelDay;
-  if (yyHaveTime || (yyHaveRel && !yyHaveDate && !yyHaveDay))
+  if ((yyHaveTime != 0) ||
+      ( (yyHaveRel != 0) && (yyHaveDate == 0) && (yyHaveDay == 0) ))
    {
      tm.tm_hour = ToHour (yyHour, yyMeridian);
      if (tm.tm_hour < 0)
--- a/libmisc/getgr_nam_gid.c
+++ b/libmisc/getgr_nam_gid.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 1991 - 1994, Julianne Frances Haugh
+ * Copyright (c) 1996 - 2000, Marek Michałkiewicz
+ * Copyright (c) 2000 - 2006, Tomasz Kłoczko
+ * Copyright (c) 2007 - 2009, Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id$"
+
+#include <stdlib.h>
+#include <errno.h>
+#include <grp.h>
+#include "prototypes.h"
+
+/*
+ * getgr_nam_gid - Return a pointer to the group specified by a string.
+ * The string may be a valid GID or a valid groupname.
+ * If the group does not exist on the system, NULL is returned.
+ */
+extern /*@only@*//*@null@*/struct group *getgr_nam_gid (/*@null@*/const char *grname)
+{
+	long long int gid;
+	char *endptr;
+
+	if (NULL == grname) {
+		return NULL;
+	}
+
+	errno = 0;
+	gid = strtoll (grname, &endptr, 10);
+	if (   ('\0' != *grname)
+	    && ('\0' == *endptr)
+	    && (ERANGE != errno)
+	    && (/*@+longintegral@*/gid == (gid_t)gid)/*@=longintegral@*/) {
+		return xgetgrgid ((gid_t) gid);
+	}
+	return xgetgrnam (grname);
+}
+
--- a/libmisc/getrange.c
+++ b/libmisc/getrange.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2008       , Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id: $"
+
+#include <ctype.h>
+#include <stdlib.h>
+
+#include "defines.h"
+#include "prototypes.h"
+
+/*
+ * Parse a range and indicate if the range is valid.
+ * Valid ranges are in the form:
+ *     <long>          -> min=max=long         has_min  has_max
+ *     -<long>         -> max=long            !has_min  has_max
+ *     <long>-         -> min=long             has_min !has_max
+ *     <long1>-<long2> -> min=long1 max=long2  has_min  has_max
+ *
+ * If the range is valid, getrange returns 1.
+ * If the range is not valid, getrange returns 0.
+ */
+int getrange (char *range,
+              unsigned long *min, bool *has_min,
+              unsigned long *max, bool *has_max)
+{
+	char *endptr;
+	unsigned long n;
+
+	if (NULL == range) {
+		return 0;
+	}
+
+	if ('-' == range[0]) {
+		if (!isdigit(range[1])) {
+			/* invalid */
+			return 0;
+		}
+		errno = 0;
+		n = strtoul (&range[1], &endptr, 10);
+		if (('\0' != *endptr) || (ERANGE == errno)) {
+			/* invalid */
+			return 0;
+		}
+		/* -<long> */
+		*has_min = false;
+		*has_max = true;
+		*max = n;
+	} else {
+		errno = 0;
+		n = strtoul (range, &endptr, 10);
+		if (ERANGE == errno) {
+			/* invalid */
+			return 0;
+		}
+		switch (*endptr) {
+			case '\0':
+				/* <long> */
+				*has_min = true;
+				*has_max = true;
+				*min = n;
+				*max = n;
+				break;
+			case '-':
+				endptr++;
+				if ('\0' == *endptr) {
+					/* <long>- */
+					*has_min = true;
+					*has_max = false;
+					*min = n;
+				} else if (!isdigit (*endptr)) {
+					/* invalid */
+					return 0;
+				} else {
+					*has_min = true;
+					*min = n;
+					errno = 0;
+					n = strtoul (endptr, &endptr, 10);
+					if (   ('\0' != *endptr)
+					    || (ERANGE == errno)) {
+						/* invalid */
+						return 0;
+					}
+					/* <long>-<long> */
+					*has_max = true;
+					*max = n;
+				}
+				break;
+			default:
+				return 0;
+		}
+	}
+
+	return 1;
+}
+
--- a/libmisc/hushed.c
+++ b/libmisc/hushed.c
@@ -3,6 +3,7 @@
 * Copyright (c) 1991 - 1993, Chip Rosenthal
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2008 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -36,21 +37,22 @@

 #include <sys/types.h>
 #include <stdio.h>
+#include <pwd.h>
 #include "defines.h"
 #include "prototypes.h"
 #include "getdef.h"
-#include <pwd.h>
 /*
 * hushed - determine if a user receives login messages
 *
 * Look in the hushed-logins file (or user's home directory) to see
 * if the user is to receive the login-time messages.
 */
-int hushed (const struct passwd *pw)
+bool hushed (const char *username)
 {
-	char *hushfile;
+	struct passwd *pw;
+	const char *hushfile;
 	char buf[BUFSIZ];
-	int found;
+	bool found;
 	FILE *fp;

 	/*
@@ -58,8 +60,15 @@ int hushed (const struct passwd *pw)
 	 * defined, default to a noisy login.
 	 */

-	if ((hushfile = getdef_str ("HUSHLOGIN_FILE")) == NULL)
-		return 0;
+	hushfile = getdef_str ("HUSHLOGIN_FILE");
+	if (NULL == hushfile) {
+		return false;
+	}
+
+	pw = getpwnam (username);
+	if (NULL == pw) {
+		return false;
+	}

 	/*
 	 * If this is not a fully rooted path then see if the
@@ -67,23 +76,25 @@ int hushed (const struct passwd *pw)
 	 */

 	if (hushfile[0] != '/') {
-		snprintf (buf, sizeof (buf), "%s/%s", pw->pw_dir, hushfile);
+		(void) snprintf (buf, sizeof (buf), "%s/%s", pw->pw_dir, hushfile);
 		return (access (buf, F_OK) == 0);
 	}

 	/*
 	 * If this is a fully rooted path then go through the file
-	 * and see if this user is in there.
+	 * and see if this user, or its shell is in there.
 	 */

-	if ((fp = fopen (hushfile, "r")) == NULL)
-		return 0;
-
-	for (found = 0; !found && fgets (buf, sizeof buf, fp);) {
+	fp = fopen (hushfile, "r");
+	if (NULL == fp) {
+		return false;
+	}
+	for (found = false; !found && (fgets (buf, (int) sizeof buf, fp) == buf);) {
 		buf[strlen (buf) - 1] = '\0';
-		found = !strcmp (buf,
-				 buf[0] == '/' ? pw->pw_shell : pw->pw_name);
+		found = (strcmp (buf, pw->pw_shell) == 0) ||
+		        (strcmp (buf, pw->pw_name) == 0);
 	}
 	(void) fclose (fp);
 	return found;
 }
+
--- a/libmisc/idmapping.c
+++ b/libmisc/idmapping.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2013 Eric Biederman
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "prototypes.h"
+#include "idmapping.h"
+
+struct map_range *get_map_ranges(int ranges, int argc, char **argv)
+{
+	struct map_range *mappings, *mapping;
+	int idx, argidx;
+
+	if (ranges < 0 || argc < 0) {
+		fprintf(stderr, "%s: error calculating number of arguments\n", Prog);
+		return NULL;
+	}
+
+	if (ranges != ((argc + 2) / 3)) {
+		fprintf(stderr, "%s: ranges: %u is wrong for argc: %d\n", Prog, ranges, argc);
+		return NULL;
+	}
+
+	if ((ranges * 3) > argc) {
+		fprintf(stderr, "ranges: %u argc: %d\n",
+			ranges, argc);
+		fprintf(stderr,
+			_( "%s: Not enough arguments to form %u mappings\n"),
+			Prog, ranges);
+		return NULL;
+	}
+
+	mappings = calloc(ranges, sizeof(*mappings));
+	if (!mappings) {
+		fprintf(stderr, _( "%s: Memory allocation failure\n"),
+			Prog);
+		exit(EXIT_FAILURE);
+	}
+
+	/* Gather up the ranges from the command line */
+	mapping = mappings;
+	for (idx = 0; idx < ranges; idx++, argidx += 3, mapping++) {
+		if (!getulong(argv[argidx + 0], &mapping->upper))
+			return NULL;
+		if (!getulong(argv[argidx + 1], &mapping->lower))
+			return NULL;
+		if (!getulong(argv[argidx + 2], &mapping->count))
+			return NULL;
+	}
+	return mappings;
+}
+
+/* Number of ascii digits needed to print any unsigned long in decimal.
+ * There are approximately 10 bits for every 3 decimal digits.
+ * So from bits to digits the formula is roundup((Number of bits)/10) * 3.
+ * For common sizes of integers this works out to:
+ *  2bytes -->  6 ascii estimate  -> 65536  (5 real)
+ *  4bytes --> 12 ascii estimated -> 4294967296 (10 real)
+ *  8bytes --> 21 ascii estimated -> 18446744073709551616 (20 real)
+ * 16bytes --> 39 ascii estimated -> 340282366920938463463374607431768211456 (39 real)
+ */
+#define ULONG_DIGITS ((((sizeof(unsigned long) * CHAR_BIT) + 9)/10)*3)
+
+
+void write_mapping(int proc_dir_fd, int ranges, struct map_range *mappings,
+	const char *map_file)
+{
+	int idx;
+	struct map_range *mapping;
+	size_t bufsize;
+	char *buf, *pos;
+	int fd;
+
+	bufsize = ranges * ((ULONG_DIGITS  + 1) * 3);
+	pos = buf = xmalloc(bufsize);
+
+	/* Build the mapping command */
+	mapping = mappings;
+	for (idx = 0; idx < ranges; idx++, mapping++) {
+		/* Append this range to the string that will be written */
+		int written = snprintf(pos, bufsize - (pos - buf),
+			"%lu %lu %lu\n",
+			mapping->upper,
+			mapping->lower,
+			mapping->count);
+		if ((written <= 0) || (written >= (bufsize - (pos - buf)))) {
+			fprintf(stderr, _("%s: snprintf failed!\n"), Prog);
+			exit(EXIT_FAILURE);
+		}
+		pos += written;
+	}
+
+	/* Write the mapping to the maping file */
+	fd = openat(proc_dir_fd, map_file, O_WRONLY);
+	if (fd < 0) {
+		fprintf(stderr, _("%s: open of %s failed: %s\n"),
+			Prog, map_file, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+	if (write(fd, buf, pos - buf) != (pos - buf)) {
+		fprintf(stderr, _("%s: write to %s failed: %s\n"),
+			Prog, map_file, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+	close(fd);
+}
--- a/libmisc/idmapping.h
+++ b/libmisc/idmapping.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2013 Eric Biederman
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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 _IDMAPPING_H_
+#define _IDMAPPING_H_
+
+struct map_range {
+	unsigned long upper; /* first ID inside the namespace */
+	unsigned long lower; /* first ID outside the namespace */
+	unsigned long count; /* Length of the inside and outside ranges */
+};
+
+extern struct map_range *get_map_ranges(int ranges, int argc, char **argv);
+extern void write_mapping(int proc_dir_fd, int ranges,
+	struct map_range *mappings, const char *map_file);
+
+#endif /* _ID_MAPPING_H_ */
+
--- a/libmisc/isexpired.c
+++ b/libmisc/isexpired.c
@@ -2,6 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1997, Marek Michałkiewicz
 * Copyright (c) 2001 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2008 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -50,15 +51,23 @@
 *
 *	isexpired calculates the expiration date based on the
 *	password expiration criteria.
+ *
+ * Return value:
+ *	0: The password is still valid
+ *	1: The password has expired, it must be changed
+ *	2: The password has expired since a long time and the account is
+ *	   now disabled. (password cannot be changed)
+ *	3: The account has expired
 */
- /*ARGSUSED*/ int isexpired (const struct passwd *pw, const struct spwd *sp)
+int isexpired (const struct passwd *pw, /*@null@*/const struct spwd *sp)
 {
 	long now;

-	now = time ((time_t *) 0) / SCALE;
+	now = (long) time ((time_t *) 0) / SCALE;

-	if (!sp)
-		sp = pwd_to_spwd (pw);
+	if (NULL == sp) {
+		return 0;
+	}

 	/*
 	 * Quick and easy - there is an expired account field
@@ -66,8 +75,9 @@
 	 * one first since it is worse.
 	 */

-	if (sp->sp_expire > 0 && now >= sp->sp_expire)
+	if ((sp->sp_expire > 0) && (now >= sp->sp_expire)) {
 		return 3;
+	}

 	/*
 	 * Last changed date 1970-01-01 (not very likely) means that
@@ -77,12 +87,17 @@
 	 * if /etc/shadow doesn't exist, getspnam() still succeeds and
 	 * returns sp_lstchg==0 (must change password) instead of -1!
 	 */
-	if (sp->sp_lstchg == 0 && !strcmp (pw->pw_passwd, SHADOW_PASSWD_STRING))
+	if (   (0 == sp->sp_lstchg)
+	    && (strcmp (pw->pw_passwd, SHADOW_PASSWD_STRING) == 0)) {
 		return 1;
+	}

-	if (sp->sp_lstchg > 0 && sp->sp_max >= 0 && sp->sp_inact >= 0 &&
-	    now >= sp->sp_lstchg + sp->sp_max + sp->sp_inact)
+	if (   (sp->sp_lstchg > 0)
+	    && (sp->sp_max >= 0)
+	    && (sp->sp_inact >= 0)
+	    && (now >= (sp->sp_lstchg + sp->sp_max + sp->sp_inact))) {
 		return 2;
+	}

 	/*
 	 * The last and max fields must be present for an account
@@ -90,9 +105,11 @@
 	 * is considered to be infinite.
 	 */

-	if (sp->sp_lstchg == -1 ||
-	    sp->sp_max == -1 || sp->sp_max >= (10000L * DAY / SCALE))
+	if (   (-1 == sp->sp_lstchg)
+	    || (-1 == sp->sp_max)
+	    || (sp->sp_max >= ((10000L * DAY) / SCALE))) {
 		return 0;
+	}

 	/*
 	 * Calculate today's day and the day on which the password
@@ -100,7 +117,9 @@
 	 * the password has expired.
 	 */

-	if (now >= sp->sp_lstchg + sp->sp_max)
+	if (now >= (sp->sp_lstchg + sp->sp_max)) {
 		return 1;
+	}
 	return 0;
 }
+
--- a/libmisc/limits.c
+++ b/libmisc/limits.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1999, Marek Michałkiewicz
 * Copyright (c) 2003 - 2006, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -33,6 +33,7 @@
 /*
 * Separated from setup.c.  --marekm
 * Resource limits thanks to Cristian Gafton.
+ * Enhancements of resource limit code by Thomas Orgis <thomas@orgis.org>
 */

 #include <config.h>
@@ -44,6 +45,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdio.h>
+#include <ctype.h>
 #include "prototypes.h"
 #include "defines.h"
 #include <pwd.h>
@@ -64,50 +66,78 @@
 *	value - string value to be read
 *	multiplier - value*multiplier is the actual limit
 */
-static int
-setrlimit_value (unsigned int rlimit, const char *value,
-		 unsigned int multiplier)
+static int setrlimit_value (unsigned int resource,
+                            const char *value,
+                            unsigned int multiplier)
 {
 	struct rlimit rlim;
-	long limit;
-	char **endptr = (char **) &value;
-	const char *value_orig = value;
+	rlim_t limit;
+
+	/* The "-" is special, not belonging to a strange negative limit.
+	 * It is infinity, in a controlled way.
+	 */
+	if ('-' == value[0]) {
+		limit = RLIM_INFINITY;
+	}
+	else {
+		/* We cannot use getlong here because it fails when there
+		 * is more to the value than just this number!
+		 * Also, we are limited to base 10 here (hex numbers will not
+		 * work with the limit string parser as is anyway)
+		 */
+		char *endptr;
+		long longlimit = strtol (value, &endptr, 10);
+		if ((0 == longlimit) && (value == endptr)) {
+			/* No argument at all. No-op.
+			 * FIXME: We could instead throw an error, though.
+			 */
+			return 0;
+		}
+		longlimit *= multiplier;
+		limit = (rlim_t)longlimit;
+		if (longlimit != limit)
+		{
+			/* FIXME: Again, silent error handling...
+			 * Wouldn't screaming make more sense?
+			 */
+			return 0;
+		}
+	}

-	limit = strtol (value, endptr, 10);
-	if (limit == 0 && value_orig == *endptr)	/* no chars read */
-		return 0;
-	limit *= multiplier;
 	rlim.rlim_cur = limit;
 	rlim.rlim_max = limit;
-	if (setrlimit (rlimit, &rlim))
+	if (setrlimit (resource, &rlim) != 0) {
 		return LOGIN_ERROR_RLIMIT;
+	}
 	return 0;
 }


 static int set_prio (const char *value)
 {
-	int prio;
-	char **endptr = (char **) &value;
+	long prio;

-	prio = strtol (value, endptr, 10);
-	if ((prio == 0) && (value == *endptr))
+	if (   (getlong (value, &prio) == 0)
+	    || (prio != (int) prio)) {
 		return 0;
-	if (setpriority (PRIO_PROCESS, 0, prio))
+	}
+	if (setpriority (PRIO_PROCESS, 0, (int) prio) != 0) {
 		return LOGIN_ERROR_RLIMIT;
+	}
 	return 0;
 }


 static int set_umask (const char *value)
 {
-	mode_t mask;
-	char **endptr = (char **) &value;
+	unsigned long int mask;

-	mask = strtol (value, endptr, 8) & 0777;
-	if ((mask == 0) && (value == *endptr))
+	if (   (getulong (value, &mask) == 0)
+	    || (mask != (mode_t) mask)) {
 		return 0;
-	umask (mask);
+	}
+
+	(void) umask ((mode_t) mask);
 	return 0;
 }

@@ -115,53 +145,58 @@ static int set_umask (const char *value)
 /* Counts the number of user logins and check against the limit */
 static int check_logins (const char *name, const char *maxlogins)
 {
-#if HAVE_UTMPX_H
+#ifdef USE_UTMPX
 	struct utmpx *ut;
-#else
+#else				/* !USE_UTMPX */
 	struct utmp *ut;
-#endif
-	unsigned int limit, count;
-	char **endptr = (char **) &maxlogins;
-	const char *ml_orig = maxlogins;
+#endif				/* !USE_UTMPX */
+	unsigned long limit, count;

-	limit = strtol (maxlogins, endptr, 10);
-	if (limit == 0 && ml_orig == *endptr)	/* no chars read */
+	if (getulong (maxlogins, &limit) == 0) {
 		return 0;
+	}

-	if (limit == 0) {	/* maximum 0 logins ? */
+	if (0 == limit) {	/* maximum 0 logins ? */
 		SYSLOG ((LOG_WARN, "No logins allowed for `%s'\n", name));
 		return LOGIN_ERROR_LOGIN;
 	}

 	count = 0;
-#if HAVE_UTMPX_H
+#ifdef USE_UTMPX
 	setutxent ();
-	while ((ut = getutxent ())) {
-#else
+	while ((ut = getutxent ()))
+#else				/* !USE_UTMPX */
 	setutent ();
-	while ((ut = getutent ())) {
-#endif
-		if (ut->ut_type != USER_PROCESS)
+	while ((ut = getutent ()))
+#endif				/* !USE_UTMPX */
+	{
+		if (USER_PROCESS != ut->ut_type) {
 			continue;
-		if (ut->ut_user[0] == '\0')
+		}
+		if ('\0' == ut->ut_user[0]) {
 			continue;
-		if (strncmp (name, ut->ut_user, sizeof (ut->ut_user)) != 0)
+		}
+		if (strncmp (name, ut->ut_user, sizeof (ut->ut_user)) != 0) {
 			continue;
-		if (++count > limit)
+		}
+		count++;
+		if (count > limit) {
 			break;
+		}
 	}
-#if HAVE_UTMPX_H
+#ifdef USE_UTMPX
 	endutxent ();
-#else
+#else				/* !USE_UTMPX */
 	endutent ();
-#endif
+#endif				/* !USE_UTMPX */
 	/*
 	 * This is called after setutmp(), so the number of logins counted
 	 * includes the user who is currently trying to log in.
 	 */
 	if (count > limit) {
-		SYSLOG ((LOG_WARN, "Too many logins (max %d) for %s\n",
-			 limit, name));
+		SYSLOG ((LOG_WARN,
+		         "Too many logins (max %lu) for %s\n",
+		         limit, name));
 		return LOGIN_ERROR_LOGIN;
 	}
 	return 0;
@@ -179,17 +214,20 @@ static int check_logins (const char *name, const char *maxlogins)
 * [Cc]: c = RLIMIT_CORE	max core file size (KB)
 * [Dd]: d = RLIMIT_DATA	max data size (KB)
 * [Ff]: f = RLIMIT_FSIZE	max file size (KB)
+ * [Ii]: i = RLIMIT_NICE    max nice value (0..39 translates to 20..-19)
+ * [Kk]: k = file creation masK (umask)
+ * [Ll]: l = max number of logins for this user
 * [Mm]: m = RLIMIT_MEMLOCK	max locked-in-memory address space (KB)
 * [Nn]: n = RLIMIT_NOFILE	max number of open files
+ * [Oo]: o = RLIMIT_RTPRIO  max real time priority (linux/sched.h 0..MAX_RT_PRIO)
+ * [Pp]: p = process priority -20..20 (negative = high, positive = low)
 * [Rr]: r = RLIMIT_RSS		max resident set size (KB)
 * [Ss]: s = RLIMIT_STACK	max stack size (KB)
 * [Tt]: t = RLIMIT_CPU		max CPU time (MIN)
 * [Uu]: u = RLIMIT_NPROC	max number of processes
- * [Kk]: k = file creation masK (umask)
- * [Ll]: l = max number of logins for this user
- * [Pp]: p = process priority -20..20 (negative = high, positive = low)
- * [Ii]: i = RLIMIT_NICE    max nice value (0..39 translates to 20..-19)
- * [Oo]: o = RLIMIT_RTPRIO  max real time priority (linux/sched.h 0..MAX_RT_PRIO)
+ *
+ * NOTE: Remember to extend the "no-limits" string below when adding a new
+ * limit...
 *
 * Return value:
 *		0 = okay, of course
@@ -203,10 +241,29 @@ static int do_user_limits (const char *buf, const char *name)
 {
 	const char *pp;
 	int retval = 0;
+	bool reported = false;

 	pp = buf;
+	/* Skip leading whitespace. */
+	while ((' ' == *pp) || ('\t' == *pp)) {
+		pp++;
+	}

-	while (*pp != '\0')
+	/* The special limit string "-" results in no limit for all known
+	 * limits.
+	 * We achieve that by parsing a full limit string, parts of it
+	 * being ignored if a limit type is not known to the system.
+	 * Though, there will be complaining for unknown limit types.
+	 */
+	if (strcmp (pp, "-") == 0) {
+		/* Remember to extend this, too, when adding new limits!
+		 * Oh... but "unlimited" does not make sense for umask,
+		 * or does it? (K-)
+		 */
+		pp = "A- C- D- F- I- L- M- N- O- P- R- S- T- U-";
+	}
+
+	while ('\0' != *pp) {
 		switch (*pp++) {
 #ifdef RLIMIT_AS
 		case 'a':
@@ -215,11 +272,11 @@ static int do_user_limits (const char *buf, const char *name)
 			retval |= setrlimit_value (RLIMIT_AS, pp, 1024);
 			break;
 #endif
-#ifdef RLIMIT_CPU
-		case 't':
-		case 'T':
-			/* RLIMIT_CPU - max CPU time (MIN) */
-			retval |= setrlimit_value (RLIMIT_CPU, pp, 60);
+#ifdef RLIMIT_CORE
+		case 'c':
+		case 'C':
+			/* RLIMIT_CORE - max core file size (KB) */
+			retval |= setrlimit_value (RLIMIT_CORE, pp, 1024);
 			break;
 #endif
 #ifdef RLIMIT_DATA
@@ -236,20 +293,22 @@ static int do_user_limits (const char *buf, const char *name)
 			retval |= setrlimit_value (RLIMIT_FSIZE, pp, 1024);
 			break;
 #endif
-#ifdef RLIMIT_NPROC
-		case 'u':
-		case 'U':
-			/* RLIMIT_NPROC - max number of processes */
-			retval |= setrlimit_value (RLIMIT_NPROC, pp, 1);
+#ifdef RLIMIT_NICE
+		case 'i':
+		case 'I':
+			/* RLIMIT_NICE - max scheduling priority (0..39) */
+			retval |= setrlimit_value (RLIMIT_NICE, pp, 1);
 			break;
 #endif
-#ifdef RLIMIT_CORE
-		case 'c':
-		case 'C':
-			/* RLIMIT_CORE - max core file size (KB) */
-			retval |= setrlimit_value (RLIMIT_CORE, pp, 1024);
+		case 'k':
+		case 'K':
+			retval |= set_umask (pp);
+			break;
+		case 'l':
+		case 'L':
+			/* LIMIT the number of concurrent logins */
+			retval |= check_logins (name, pp);
 			break;
-#endif
 #ifdef RLIMIT_MEMLOCK
 		case 'm':
 		case 'M':
@@ -264,6 +323,17 @@ static int do_user_limits (const char *buf, const char *name)
 			retval |= setrlimit_value (RLIMIT_NOFILE, pp, 1);
 			break;
 #endif
+#ifdef RLIMIT_RTPRIO
+		case 'o':
+		case 'O':
+			/* RLIMIT_RTPRIO - max real time priority (0..MAX_RT_PRIO) */
+			retval |= setrlimit_value (RLIMIT_RTPRIO, pp, 1);
+			break;
+#endif
+		case 'p':
+		case 'P':
+			retval |= set_prio (pp);
+			break;
 #ifdef RLIMIT_RSS
 		case 'r':
 		case 'R':
@@ -278,40 +348,81 @@ static int do_user_limits (const char *buf, const char *name)
 			retval |= setrlimit_value (RLIMIT_STACK, pp, 1024);
 			break;
 #endif
-#ifdef RLIMIT_NICE
-		case 'i':
-		case 'I':
-			/* RLIMIT_NICE - max scheduling priority (0..39) */
-			retval |= setrlimit_value (RLIMIT_NICE, pp, 1);
+#ifdef RLIMIT_CPU
+		case 't':
+		case 'T':
+			/* RLIMIT_CPU - max CPU time (MIN) */
+			retval |= setrlimit_value (RLIMIT_CPU, pp, 60);
 			break;
 #endif
-#ifdef RLIMIT_RTPRIO
-		case 'o':
-		case 'O':
-			/* RLIMIT_RTPRIO - max real time priority (0..MAX_RT_PRIO) */
-			retval |= setrlimit_value (RLIMIT_RTPRIO, pp, 1);
+#ifdef RLIMIT_NPROC
+		case 'u':
+		case 'U':
+			/* RLIMIT_NPROC - max number of processes */
+			retval |= setrlimit_value (RLIMIT_NPROC, pp, 1);
 			break;
 #endif
-		case 'k':
-		case 'K':
-			retval |= set_umask (pp);
-			break;
-		case 'l':
-		case 'L':
-			/* LIMIT the number of concurent logins */
-			retval |= check_logins (name, pp);
-			break;
-		case 'p':
-		case 'P':
-			retval |= set_prio (pp);
-			break;
+		default:
+			/* Only report invalid strings once */
+			/* Note: A string can be invalid just because a
+			 * specific (theoretically valid) setting is not
+			 * supported by this build.
+			 * It is just a warning in syslog anyway. The line
+			 * is still processed
+			 */
+			if (!reported) {
+				SYSLOG ((LOG_WARN,
+				         "Invalid limit string: '%s'",
+				         pp-1));
+				reported = true;
+				retval |= LOGIN_ERROR_RLIMIT;
+			}
 		}
+		/* After parsing one limit setting (or just complaining
+		 * about it), one still needs to skip its argument to
+		 * prevent a bogus warning on trying to parse that as
+		 * limit specification.
+		 * So, let's skip all digits, "-" and our limited set of
+		 * whitespace.
+		 */
+		while (   isdigit (*pp)
+		       || ('-'  == *pp)
+		       || (' '  == *pp)
+		       || ('\t' ==*pp)) {
+			pp++;
+		}
+	}
 	return retval;
 }

+/* Check if user uname is in the group gname.
+ * Can I be sure that gr_mem contains no UID as string?
+ * Returns true when user is in the group, false when not.
+ * Any error is treated as false.
+ */
+static bool user_in_group (const char *uname, const char *gname)
+{
+	struct group *groupdata;
+
+	if (uname == NULL || gname == NULL){ 
+		return false;
+	}
+
+	/* We are not claiming to be re-entrant!
+	 * In case of paranoia or a multithreaded login program,
+	 * one needs to add some mess for getgrnam_r. */
+	groupdata = getgrnam (gname);
+	if (NULL == groupdata) {
+		SYSLOG ((LOG_WARN, "Nonexisting group `%s' in limits file.",
+		         gname));
+		return false;
+	}
+
+	return is_on_list (groupdata->gr_mem, uname);
+}
+
 static int setup_user_limits (const char *uname)
 {
-	/* TODO: allow and use @group syntax --cristiang */
 	FILE *fil;
 	char buf[1024];
 	char name[1024];
@@ -333,11 +444,14 @@ static int setup_user_limits (const char *uname)
 	}
 	/* The limits file have the following format:
 	 * - '#' (comment) chars only as first chars on a line;
-	 * - username must start on first column
-	 * A better (smarter) checking should be done --cristiang */
+	 * - username must start on first column (or *, or @group)
+	 *
+	 * FIXME: A better (smarter) checking should be done
+	 */
 	while (fgets (buf, 1024, fil) != NULL) {
-		if (buf[0] == '#' || buf[0] == '\n')
+		if (('#' == buf[0]) || ('\n' == buf[0])) {
 			continue;
+		}
 		memzero (tempbuf, sizeof (tempbuf));
 		/* a valid line should have a username, then spaces,
 		 * then limits
@@ -345,23 +459,44 @@ static int setup_user_limits (const char *uname)
 		 * username    L2  D2048  R4096
 		 * where spaces={' ',\t}. Also, we reject invalid limits.
 		 * Imposing a limit should be done with care, so a wrong
-		 * entry means no care anyway :-). A '-' as a limits
-		 * strings means no limits --cristiang */
-		if (sscanf (buf, "%s%[ACDFMNRSTULPIOacdfmnrstulpio0-9 \t-]",
-			    name, tempbuf) == 2) {
+		 * entry means no care anyway :-).
+		 *
+		 * A '-' as a limits strings means no limits
+		 *
+		 * The username can also be:
+		 *  '*': the default limits (only the last is taken into
+		 *       account)
+		 *  @group: the limit applies to the members of the group
+		 *
+		 * To clarify: The first entry with matching user name rules,
+		 * everything after it is ignored. If there is no user entry,
+		 * the last encountered entry for a matching group rules.
+		 * If there is no matching group entry, the default limits rule.
+		 */
+		if (sscanf (buf, "%s%[ACDFIKLMNOPRSTUacdfiklmnoprstu0-9 \t-]",
+		            name, tempbuf) == 2) {
 			if (strcmp (name, uname) == 0) {
 				strcpy (limits, tempbuf);
 				break;
 			} else if (strcmp (name, "*") == 0) {
 				strcpy (deflimits, tempbuf);
+			} else if (name[0] == '@') {
+				/* If the user is in the group, the group
+				 * limits apply unless later a line for
+				 * the specific user is found.
+				 */
+				if (user_in_group (uname, name+1)) {
+					strcpy (limits, tempbuf);
+				}
 			}
 		}
 	}
-	fclose (fil);
+	(void) fclose (fil);
 	if (limits[0] == '\0') {
 		/* no user specific limits */
-		if (deflimits[0] == '\0')	/* no default limits */
+		if (deflimits[0] == '\0') {	/* no default limits */
 			return 0;
+		}
 		strcpy (limits, deflimits);	/* use the default limits */
 	}
 	return do_user_limits (limits, uname);
@@ -372,19 +507,21 @@ static int setup_user_limits (const char *uname)
 static void setup_usergroups (const struct passwd *info)
 {
 	const struct group *grp;
-	mode_t oldmask;

 /*
 *	if not root, and UID == GID, and username is the same as primary
 *	group name, set umask group bits to be the same as owner bits
 *	(examples: 022 -> 002, 077 -> 007).
 */
-	if (info->pw_uid != 0 && info->pw_uid == info->pw_gid) {
+	if ((0 != info->pw_uid) && (info->pw_uid == info->pw_gid)) {
 		/* local, no need for xgetgrgid */
 		grp = getgrgid (info->pw_gid);
-		if (grp && (strcmp (info->pw_name, grp->gr_name) == 0)) {
-			oldmask = umask (0777);
-			umask ((oldmask & ~070) | ((oldmask >> 3) & 070));
+		if (   (NULL != grp)
+		    && (strcmp (info->pw_name, grp->gr_name) == 0)) {
+			mode_t tmpmask;
+			tmpmask = umask (0777);
+			tmpmask = (tmpmask & ~070) | ((tmpmask >> 3) & 070);
+			(void) umask (tmpmask);
 		}
 	}
 }
@@ -396,11 +533,10 @@ static void setup_usergroups (const struct passwd *info)
 void setup_limits (const struct passwd *info)
 {
 	char *cp;
-	int i;
-	long l;

-	if (getdef_bool ("USERGROUPS_ENAB"))
+	if (getdef_bool ("USERGROUPS_ENAB")) {
 		setup_usergroups (info);
+	}

 	/*
 	 * See if the GECOS field contains values for NICE, UMASK or ULIMIT.
@@ -410,33 +546,58 @@ void setup_limits (const struct passwd *info)

 	if (getdef_bool ("QUOTAS_ENAB")) {
 #ifdef LIMITS
-		if (info->pw_uid != 0)
-			if (setup_user_limits (info->pw_name) &
-			    LOGIN_ERROR_LOGIN) {
-				fputs (_("Too many logins.\n"), stderr);
-				sleep (2);
-				exit (1);
+		if (info->pw_uid != 0) {
+			if ((setup_user_limits (info->pw_name) & LOGIN_ERROR_LOGIN) != 0) {
+				(void) fputs (_("Too many logins.\n"), stderr);
+				(void) sleep (2); /* XXX: Should be FAIL_DELAY */
+				exit (EXIT_FAILURE);
 			}
+		}
 #endif
 		for (cp = info->pw_gecos; cp != NULL; cp = strchr (cp, ',')) {
-			if (*cp == ',')
+			if (',' == *cp) {
 				cp++;
+			}

 			if (strncmp (cp, "pri=", 4) == 0) {
-				i = atoi (cp + 4);
-				if (i >= -20 && i <= 20)
-					(void) nice (i);
+				long int inc;
+				if (   (getlong (cp + 4, &inc) == 1)
+				    && (inc >= -20) && (inc <= 20)) {
+					errno = 0;
+					if (   (nice ((int) inc) != -1)
+					    || (0 != errno)) {
+						continue;
+					}
+				}
+
+				/* Failed to parse or failed to nice() */
+				SYSLOG ((LOG_WARN,
+				         "Can't set the nice value for user %s",
+				         info->pw_name));

 				continue;
 			}
 			if (strncmp (cp, "ulimit=", 7) == 0) {
-				l = strtol (cp + 7, (char **) 0, 10);
-				set_filesize_limit (l);
+				long int blocks;
+				if (   (getlong (cp + 7, &blocks) == 0)
+				    || (blocks != (int) blocks)
+				    || (set_filesize_limit ((int) blocks) != 0)) {
+					SYSLOG ((LOG_WARN,
+					         "Can't set the ulimit for user %s",
+					         info->pw_name));
+				}
 				continue;
 			}
 			if (strncmp (cp, "umask=", 6) == 0) {
-				i = strtol (cp + 6, (char **) 0, 8) & 0777;
-				(void) umask (i);
+				unsigned long int mask;
+				if (   (getulong (cp + 6, &mask) == 0)
+				    || (mask != (mode_t) mask)) {
+					SYSLOG ((LOG_WARN,
+					         "Can't set umask value for user %s",
+					         info->pw_name));
+				} else {
+					(void) umask ((mode_t) mask);
+				}

 				continue;
 			}
--- a/libmisc/list.c
+++ b/libmisc/list.c
@@ -29,13 +29,11 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-/* Removed duplicated code from gpmain.c, useradd.c, userdel.c and
-   usermod.c.  --marekm */
-
 #include <config.h>

 #ident "$Id$"

+#include <assert.h>
 #include "prototypes.h"
 #include "defines.h"
 /*
@@ -45,11 +43,14 @@
 *	name, and if not present it is added to a freshly allocated
 *	list of users.
 */
-char **add_list (char **list, const char *member)
+/*@only@*/ /*@out@*/char **add_list (/*@returned@*/ /*@only@*/char **list, const char *member)
 {
 	int i;
 	char **tmp;

+	assert (NULL != member);
+	assert (NULL != list);
+
 	/*
 	 * Scan the list for the new name.  Return the original list
 	 * pointer if it is present.
@@ -92,11 +93,14 @@ char **add_list (char **list, const char *member)
 *	list of users.
 */

-char **del_list (char **list, const char *member)
+/*@only@*/ /*@out@*/char **del_list (/*@returned@*/ /*@only@*/char **list, const char *member)
 {
 	int i, j;
 	char **tmp;

+	assert (NULL != member);
+	assert (NULL != list);
+
 	/*
 	 * Scan the list for the old name.  Return the original list
 	 * pointer if it is not present.
@@ -137,17 +141,25 @@ char **del_list (char **list, const char *member)
 	return tmp;
 }

-char **dup_list (char *const *list)
+/*
+ * Duplicate a list.
+ * The input list is not modified, but in order to allow the use of this
+ * function with list of members, the list elements are not enforced to be
+ * constant strings here.
+ */
+/*@only@*/ /*@out@*/char **dup_list (char *const *list)
 {
 	int i;
 	char **tmp;

-	for (i = 0; list[i]; i++);
+	assert (NULL != list);
+
+	for (i = 0; NULL != list[i]; i++);

 	tmp = (char **) xmalloc ((i + 1) * sizeof (char *));

 	i = 0;
-	while (*list) {
+	while (NULL != *list) {
 		tmp[i] = xstrdup (*list);
 		i++;
 		list++;
@@ -157,27 +169,40 @@ char **dup_list (char *const *list)
 	return tmp;
 }

-int is_on_list (char *const *list, const char *member)
+/*
+ * Check if member is part of the input list
+ * The input list is not modified, but in order to allow the use of this
+ * function with list of members, the list elements are not enforced to be
+ * constant strings here.
+ */
+bool is_on_list (char *const *list, const char *member)
 {
-	while (*list) {
+	assert (NULL != member);
+	assert (NULL != list);
+
+	while (NULL != *list) {
 		if (strcmp (*list, member) == 0) {
-			return 1;
+			return true;
 		}
 		list++;
 	}
-	return 0;
+
+	return false;
 }

 /*
 * comma_to_list - convert comma-separated list to (char *) array
 */

-char **comma_to_list (const char *comma)
+/*@only@*/char **comma_to_list (const char *comma)
 {
 	char *members;
 	char **array;
 	int i;
-	char *cp, *cp2;
+	char *cp;
+	char *cp2;
+
+	assert (NULL != comma);

 	/*
 	 * Make a copy since we are going to be modifying the list
--- a/libmisc/log.c
+++ b/libmisc/log.c
@@ -49,9 +49,11 @@
 *	UID is extracted from the global (struct passwd) entry and the
 *	TTY information is gotten from the (struct utmp).
 */
-void
-dolastlog (struct lastlog *ll, const struct passwd *pw, const char *line,
-	   const char *host)
+void dolastlog (
+	struct lastlog *ll,
+	const struct passwd *pw,
+	/*@unique@*/const char *line,
+	/*@unique@*/const char *host)
 {
 	int fd;
 	off_t offset;
@@ -62,18 +64,23 @@ dolastlog (struct lastlog *ll, const struct passwd *pw, const char *line,
 	 * If the file does not exist, don't create it.
 	 */

-	if ((fd = open (LASTLOG_FILE, O_RDWR)) == -1)
+	fd = open (LASTLOG_FILE, O_RDWR);
+	if (-1 == fd) {
 		return;
+	}

 	/*
 	 * The file is indexed by UID number.  Seek to the record
 	 * for this UID.  Negative UID's will create problems, but ...
 	 */

-	offset = (unsigned long) pw->pw_uid * sizeof newlog;
+	offset = (off_t) pw->pw_uid * sizeof newlog;

 	if (lseek (fd, offset, SEEK_SET) != offset) {
-		close (fd);
+		SYSLOG ((LOG_WARN,
+		         "Can't read last lastlog entry for UID %lu in %s. Entry not updated.",
+		         (unsigned long) pw->pw_uid, LASTLOG_FILE));
+		(void) close (fd);
 		return;
 	}

@@ -83,19 +90,27 @@ dolastlog (struct lastlog *ll, const struct passwd *pw, const char *line,
 	 * the way we read the old one in.
 	 */

-	if (read (fd, (char *) &newlog, sizeof newlog) != sizeof newlog)
+	if (read (fd, (void *) &newlog, sizeof newlog) != (ssize_t) sizeof newlog) {
 		memzero (&newlog, sizeof newlog);
-	if (ll)
+	}
+	if (NULL != ll) {
 		*ll = newlog;
+	}

 	ll_time = newlog.ll_time;
-	time (&ll_time);
+	(void) time (&ll_time);
 	newlog.ll_time = ll_time;
 	strncpy (newlog.ll_line, line, sizeof newlog.ll_line);
 #if HAVE_LL_HOST
 	strncpy (newlog.ll_host, host, sizeof newlog.ll_host);
 #endif
-	if (lseek (fd, offset, SEEK_SET) == offset)
-		write (fd, (char *) &newlog, sizeof newlog);
-	close (fd);
+	if (   (lseek (fd, offset, SEEK_SET) != offset)
+	    || (write (fd, (const void *) &newlog, sizeof newlog) != (ssize_t) sizeof newlog)
+	    || (close (fd) != 0)) {
+		SYSLOG ((LOG_WARN,
+		         "Can't write lastlog entry for UID %lu in %s.",
+		         (unsigned long) pw->pw_uid, LASTLOG_FILE));
+		(void) close (fd);
+	}
 }
+
--- a/libmisc/loginprompt.c
+++ b/libmisc/loginprompt.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1993, Julianne Frances Haugh
 * Copyright (c) 1996 - 2000, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2008       , Nicolas François
+ * Copyright (c) 2008 - 2011, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,7 @@

 #ident "$Id$"

+#include <assert.h>
 #include <stdio.h>
 #include <signal.h>
 #include <ctype.h>
@@ -43,7 +44,7 @@

 static void login_exit (unused int sig)
 {
-	exit (1);
+	exit (EXIT_FAILURE);
 }

 /*
@@ -59,7 +60,6 @@ void login_prompt (const char *prompt, char *name, int namesize)

 #define MAX_ENV 32
 	char *envp[MAX_ENV];
-	int envc;
 	char *cp;
 	int i;
 	FILE *fp;
@@ -86,17 +86,21 @@ void login_prompt (const char *prompt, char *name, int namesize)
 	 * be displayed and display it before the prompt.
 	 */

-	if (prompt) {
-		cp = getdef_str ("ISSUE_FILE");
-		if (cp && (fp = fopen (cp, "r"))) {
-			while ((i = getc (fp)) != EOF)
-				putc (i, stdout);
+	if (NULL != prompt) {
+		const char *fname = getdef_str ("ISSUE_FILE");
+		if (NULL != fname) {
+			fp = fopen (fname, "r");
+			if (NULL != fp) {
+				while ((i = getc (fp)) != EOF) {
+					(void) putc (i, stdout);
+				}

-			fclose (fp);
+				(void) fclose (fp);
+			}
 		}
-		gethostname (buf, sizeof buf);
+		(void) gethostname (buf, sizeof buf);
 		printf (prompt, buf);
-		fflush (stdout);
+		(void) fflush (stdout);
 	}

 	/* 
@@ -105,12 +109,14 @@ void login_prompt (const char *prompt, char *name, int namesize)
 	 */

 	memzero (buf, sizeof buf);
-	if (fgets (buf, sizeof buf, stdin) != buf)
-		exit (1);
+	if (fgets (buf, (int) sizeof buf, stdin) != buf) {
+		exit (EXIT_FAILURE);
+	}

 	cp = strchr (buf, '\n');
-	if (!cp)
-		exit (1);
+	if (NULL == cp) {
+		exit (EXIT_FAILURE);
+	}
 	*cp = '\0';		/* remove \n [ must be there ] */

 	/*
@@ -122,11 +128,13 @@ void login_prompt (const char *prompt, char *name, int namesize)
 	for (cp = buf; *cp == ' ' || *cp == '\t'; cp++);

 	for (i = 0; i < namesize - 1 && isgraph (*cp); name[i++] = *cp++);
-	while (isgraph (*cp))
+	while (isgraph (*cp)) {
 		cp++;
+	}

-	if (*cp)
+	if ('\0' != *cp) {
 		cp++;
+	}

 	name[i] = '\0';

@@ -136,19 +144,23 @@ void login_prompt (const char *prompt, char *name, int namesize)
 	 * to do this, and I just take the easy way out.
 	 */

-	if (*cp != '\0') {	/* process new variables */
+	if ('\0' != *cp) {	/* process new variables */
 		char *nvar;
 		int count = 1;
+		int envc;

 		for (envc = 0; envc < MAX_ENV; envc++) {
-			nvar = strtok (envc ? (char *) 0 : cp, " \t,");
-			if (!nvar)
+			nvar = strtok ((0 != envc) ? (char *) 0 : cp, " \t,");
+			if (NULL == nvar) {
 				break;
-			if (strchr (nvar, '=')) {
+			}
+			if (strchr (nvar, '=') != NULL) {
 				envp[envc] = nvar;
 			} else {
-				envp[envc] = xmalloc (strlen (nvar) + 32);
-				sprintf (envp[envc], "L%d=%s", count++, nvar);
+				size_t len = strlen (nvar) + 32;
+				envp[envc] = xmalloc (len);
+				(void) snprintf (envp[envc], len,
+				                 "L%d=%s", count++, nvar);
 			}
 		}
 		set_env (envc, envp);
@@ -158,8 +170,9 @@ void login_prompt (const char *prompt, char *name, int namesize)
 	 * Set the SIGQUIT handler back to its original value
 	 */

-	signal (SIGQUIT, sigquit);
+	(void) signal (SIGQUIT, sigquit);
 #ifdef	SIGTSTP
-	signal (SIGTSTP, sigtstp);
+	(void) signal (SIGTSTP, sigtstp);
 #endif
 }
+
--- a/libmisc/mail.c
+++ b/libmisc/mail.c
@@ -2,6 +2,7 @@
 * Copyright (c) 1989 - 1991, Julianne Frances Haugh
 * Copyright (c) 1996 - 1998, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2008       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -32,6 +33,7 @@
 #include <config.h>
 #include "prototypes.h"
 #include "defines.h"
+#include <assert.h>
 #include <sys/stat.h>
 #include <stdio.h>
 #include <string.h>
@@ -46,34 +48,45 @@ void mailcheck (void)
 	struct stat statbuf;
 	char *mailbox;

-	if (!getdef_bool ("MAIL_CHECK_ENAB"))
+	if (!getdef_bool ("MAIL_CHECK_ENAB")) {
 		return;
+	}

 	/*
 	 * Check incoming mail in Maildir format - J.
 	 */
-	if ((mailbox = getenv ("MAILDIR"))) {
+	mailbox = getenv ("MAILDIR");
+	if (NULL != mailbox) {
 		char *newmail;
+		size_t len = strlen (mailbox) + 5;
+		int wlen;
+
+		newmail = xmalloc (len);
+		wlen = snprintf (newmail, len, "%s/new", mailbox);
+		assert (wlen == (int) len - 1);

-		newmail = xmalloc (strlen (mailbox) + 5);
-		sprintf (newmail, "%s/new", mailbox);
 		if (stat (newmail, &statbuf) != -1 && statbuf.st_size != 0) {
 			if (statbuf.st_mtime > statbuf.st_atime) {
 				free (newmail);
-				puts (_("You have new mail."));
+				(void) puts (_("You have new mail."));
 				return;
 			}
 		}
 		free (newmail);
 	}

-	if (!(mailbox = getenv ("MAIL")))
+	mailbox = getenv ("MAIL");
+	if (NULL == mailbox) {
 		return;
+	}

-	if (stat (mailbox, &statbuf) == -1 || statbuf.st_size == 0)
-		puts (_("No mail."));
-	else if (statbuf.st_atime > statbuf.st_mtime)
-		puts (_("You have mail."));
-	else
-		puts (_("You have new mail."));
+	if (   (stat (mailbox, &statbuf) == -1)
+	    || (statbuf.st_size == 0)) {
+		(void) puts (_("No mail."));
+	} else if (statbuf.st_atime > statbuf.st_mtime) {
+		(void) puts (_("You have mail."));
+	} else {
+		(void) puts (_("You have new mail."));
+	}
 }
+
--- a/libmisc/motd.c
+++ b/libmisc/motd.c
@@ -2,6 +2,7 @@
 * Copyright (c) 1989 - 1991, Julianne Frances Haugh
 * Copyright (c) 1996 - 1997, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
+ * Copyright (c) 2010       , Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -47,21 +48,34 @@
 void motd (void)
 {
 	FILE *fp;
-	char motdlist[BUFSIZ], *motdfile, *mb;
+	char *motdlist;
+	const char *motdfile;
+	char *mb;
 	register int c;

-	if ((mb = getdef_str ("MOTD_FILE")) == NULL)
+	motdfile = getdef_str ("MOTD_FILE");
+	if (NULL == motdfile) {
 		return;
+	}

-	strncpy (motdlist, mb, sizeof (motdlist));
-	motdlist[sizeof (motdlist) - 1] = '\0';
+	motdlist = xstrdup (motdfile);

-	for (mb = motdlist; (motdfile = strtok (mb, ":")) != NULL; mb = NULL) {
-		if ((fp = fopen (motdfile, "r")) != NULL) {
-			while ((c = getc (fp)) != EOF)
+	for (mb = motdlist; ;mb = NULL) {
+		motdfile = strtok (mb, ":");
+		if (NULL == motdfile) {
+			break;
+		}
+
+		fp = fopen (motdfile, "r");
+		if (NULL != fp) {
+			while ((c = getc (fp)) != EOF) {
 				putchar (c);
+			}
 			fclose (fp);
 		}
 	}
 	fflush (stdout);
+
+	free (motdlist);
 }
+
--- a/libmisc/myname.c
+++ b/libmisc/myname.c
@@ -1,7 +1,7 @@
 /*
 * Copyright (c) 1996 - 1997, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007       , Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -41,7 +41,7 @@
 #include "defines.h"
 #include <pwd.h>
 #include "prototypes.h"
-struct passwd *get_my_pwent (void)
+/*@null@*/ /*@only@*/struct passwd *get_my_pwent (void)
 {
 	struct passwd *pw;
 	const char *cp = getlogin ();
@@ -57,8 +57,12 @@ struct passwd *get_my_pwent (void)
 	 * XXX - when running from su, will return the current user (not
 	 * the original user, like getlogin() does).  Does this matter?
 	 */
-	if (cp && *cp && (pw = xgetpwnam (cp)) && pw->pw_uid == ruid)
-		return pw;
+	if ((NULL != cp) && ('\0' != *cp)) {
+		pw = xgetpwnam (cp);
+		if ((NULL != pw) && (pw->pw_uid == ruid)) {
+			return pw;
+		}
+	}

 	return xgetpwuid (ruid);
 }
--- a/libmisc/obscure.c
+++ b/libmisc/obscure.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1999, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007 - 2008, Nicolas François
+ * Copyright (c) 2007 - 2010, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -50,24 +50,26 @@
 /*
 * can't be a palindrome - like `R A D A R' or `M A D A M'
 */
-static int palindrome (unused const char *old, const char *new)
+static bool palindrome (unused const char *old, const char *new)
 {
-	int i, j;
+	size_t i, j;

 	i = strlen (new);

-	for (j = 0; j < i; j++)
-		if (new[i - j - 1] != new[j])
-			return 0;
+	for (j = 0; j < i; j++) {
+		if (new[i - j - 1] != new[j]) {
+			return false;
+		}
+	}

-	return 1;
+	return true;
 }

 /*
 * more than half of the characters are different ones.
 */

-static int similar (const char *old, const char *new)
+static bool similar (/*@notnull@*/const char *old, /*@notnull@*/const char *new)
 {
 	int i, j;

@@ -77,41 +79,46 @@ static int similar (const char *old, const char *new)
 	 * the new password is long enough.  Please feel free to suggest
 	 * something better...  --marekm
 	 */
-	if (strlen (new) >= 8)
-		return 0;
+	if (strlen (new) >= 8) {
+		return false;
+	}

-	for (i = j = 0; new[i] && old[i]; i++)
-		if (strchr (new, old[i]))
+	for (i = j = 0; ('\0' != new[i]) && ('\0' != old[i]); i++) {
+		if (strchr (new, old[i]) != NULL) {
 			j++;
+		}
+	}

-	if (i >= j * 2)
-		return 0;
+	if (i >= j * 2) {
+		return false;
+	}

-	return 1;
+	return true;
 }

 /*
 * a nice mix of characters.
 */

-static int simple (unused const char *old, const char *new)
+static bool simple (unused const char *old, const char *new)
 {
-	int digits = 0;
-	int uppers = 0;
-	int lowers = 0;
-	int others = 0;
+	bool digits = false;
+	bool uppers = false;
+	bool lowers = false;
+	bool others = false;
 	int size;
 	int i;

-	for (i = 0; new[i]; i++) {
-		if (isdigit (new[i]))
-			digits++;
-		else if (isupper (new[i]))
-			uppers++;
-		else if (islower (new[i]))
-			lowers++;
-		else
-			others++;
+	for (i = 0; '\0' != new[i]; i++) {
+		if (isdigit (new[i])) {
+			digits = true;
+		} else if (isupper (new[i])) {
+			uppers = true;
+		} else if (islower (new[i])) {
+			lowers = true;
+		} else {
+			others = true;
+		}
 	}

 	/*
@@ -120,32 +127,40 @@ static int simple (unused const char *old, const char *new)
 	 */

 	size = 9;
-	if (digits)
+	if (digits) {
 		size--;
-	if (uppers)
+	}
+	if (uppers) {
 		size--;
-	if (lowers)
+	}
+	if (lowers) {
 		size--;
-	if (others)
+	}
+	if (others) {
 		size--;
+	}

-	if (size <= i)
-		return 0;
+	if (size <= i) {
+		return false;
+	}

-	return 1;
+	return true;
 }

-static char *str_lower (char *string)
+static char *str_lower (/*@returned@*/char *string)
 {
 	char *cp;

-	for (cp = string; *cp; cp++)
+	for (cp = string; '\0' != *cp; cp++) {
 		*cp = tolower (*cp);
+	}
 	return string;
 }

-static const char *password_check (const char *old, const char *new,
-				   const struct passwd *pwdp)
+static /*@observer@*//*@null@*/const char *password_check (
+	/*@notnull@*/const char *old,
+	/*@notnull@*/const char *new,
+	/*@notnull@*/const struct passwd *pwdp)
 {
 	const char *msg = NULL;
 	char *oldmono, *newmono, *wrapped;
@@ -160,8 +175,9 @@ static const char *password_check (const char *old, const char *new,
 #endif
 #endif

-	if (strcmp (new, old) == 0)
+	if (strcmp (new, old) == 0) {
 		return _("no change");
+	}

 	newmono = str_lower (xstrdup (new));
 	oldmono = str_lower (xstrdup (old));
@@ -169,33 +185,32 @@ static const char *password_check (const char *old, const char *new,
 	strcpy (wrapped, oldmono);
 	strcat (wrapped, oldmono);

-	if (palindrome (oldmono, newmono))
+	if (palindrome (oldmono, newmono)) {
 		msg = _("a palindrome");
-
-	if (!msg && strcmp (oldmono, newmono) == 0)
+	} else if (strcmp (oldmono, newmono) == 0) {
 		msg = _("case changes only");
-
-	if (!msg && similar (oldmono, newmono))
+	} else if (similar (oldmono, newmono)) {
 		msg = _("too similar");
-
-	if (!msg && simple (old, new))
+	} else if (simple (old, new)) {
 		msg = _("too simple");
-
-	if (!msg && strstr (wrapped, newmono))
+	} else if (strstr (wrapped, newmono) != NULL) {
 		msg = _("rotated");
-
+	} else {
 #ifdef HAVE_LIBCRACK
-	/*
-	 * Invoke Alec Muffett's cracklib routines.
-	 */
+		/*
+		 * Invoke Alec Muffett's cracklib routines.
+		 */

-	if (!msg && (dictpath = getdef_str ("CRACKLIB_DICTPATH")))
+		dictpath = getdef_str ("CRACKLIB_DICTPATH");
+		if (NULL != dictpath) {
 #ifdef HAVE_LIBCRACK_PW
-		msg = FascistCheckPw (new, dictpath, pwdp);
+			msg = FascistCheckPw (new, dictpath, pwdp);
 #else
-		msg = FascistCheck (new, dictpath);
+			msg = FascistCheck (new, dictpath);
 #endif
+		}
 #endif
+	}
 	strzero (newmono);
 	strzero (oldmono);
 	strzero (wrapped);
@@ -206,62 +221,73 @@ static const char *password_check (const char *old, const char *new,
 	return msg;
 }

- /*ARGSUSED*/
-    static const char *obscure_msg (const char *old, const char *new,
-				    const struct passwd *pwdp)
+static /*@observer@*//*@null@*/const char *obscure_msg (
+	/*@notnull@*/const char *old,
+	/*@notnull@*/const char *new,
+	/*@notnull@*/const struct passwd *pwdp)
 {
-	int maxlen, oldlen, newlen;
+	size_t maxlen, oldlen, newlen;
 	char *new1, *old1;
 	const char *msg;
-	char *result;
+	const char *result;

 	oldlen = strlen (old);
 	newlen = strlen (new);

-	if (newlen < getdef_num ("PASS_MIN_LEN", 0))
+	if (newlen < (size_t) getdef_num ("PASS_MIN_LEN", 0)) {
 		return _("too short");
+	}

 	/*
 	 * Remaining checks are optional.
 	 */
-	if (!getdef_bool ("OBSCURE_CHECKS_ENAB"))
+	if (!getdef_bool ("OBSCURE_CHECKS_ENAB")) {
 		return NULL;
+	}

 	msg = password_check (old, new, pwdp);
-	if (msg)
+	if (NULL != msg) {
 		return msg;
+	}

-	if ((result = getdef_str ("ENCRYPT_METHOD")) == NULL) {
+	result = getdef_str ("ENCRYPT_METHOD");
+	if (NULL == result) {
 	/* The traditional crypt() truncates passwords to 8 chars.  It is
 	   possible to circumvent the above checks by choosing an easy
 	   8-char password and adding some random characters to it...
 	   Example: "password$%^&*123".  So check it again, this time
 	   truncated to the maximum length.  Idea from npasswd.  --marekm */

-		if (getdef_bool ("MD5_CRYPT_ENAB"))
+		if (getdef_bool ("MD5_CRYPT_ENAB")) {
 			return NULL;
+		}

 	} else {

-		if (   !strcmp (result, "MD5")
+		if (   (strcmp (result, "MD5")    == 0)
 #ifdef USE_SHA_CRYPT
-		    || !strcmp (result, "SHA256")
-		    || !strcmp (result, "SHA512")
+		    || (strcmp (result, "SHA256") == 0)
+		    || (strcmp (result, "SHA512") == 0)
 #endif
-		    )
+		    ) {
 			return NULL;
+		}

 	}
-	maxlen = getdef_num ("PASS_MAX_LEN", 8);
-	if (oldlen <= maxlen && newlen <= maxlen)
+	maxlen = (size_t) getdef_num ("PASS_MAX_LEN", 8);
+	if (   (oldlen <= maxlen)
+	    && (newlen <= maxlen)) {
 		return NULL;
+	}

 	new1 = xstrdup (new);
 	old1 = xstrdup (old);
-	if (newlen > maxlen)
+	if (newlen > maxlen) {
 		new1[maxlen] = '\0';
-	if (oldlen > maxlen)
+	}
+	if (oldlen > maxlen) {
 		old1[maxlen] = '\0';
+	}

 	msg = password_check (old1, new1, pwdp);

@@ -281,15 +307,15 @@ static const char *password_check (const char *old, const char *new,
 *	check passwords.
 */

-int obscure (const char *old, const char *new, const struct passwd *pwdp)
+bool obscure (const char *old, const char *new, const struct passwd *pwdp)
 {
 	const char *msg = obscure_msg (old, new, pwdp);

-	if (msg) {
+	if (NULL != msg) {
 		printf (_("Bad password: %s.  "), msg);
-		return 0;
+		return false;
 	}
-	return 1;
+	return true;
 }

 #else				/* !USE_PAM */
--- a/libmisc/pam_pass.c
+++ b/libmisc/pam_pass.c
@@ -37,10 +37,7 @@


 /*
- * Change the user's password using PAM.  Requires libpam and libpam_misc
- * (for misc_conv).  Note: libpam_misc is probably Linux-PAM specific,
- * so you may have to port it if you want to use this code on non-Linux
- * systems with PAM (such as Solaris 2.6).  --marekm
+ * Change the user's password using PAM.
 */
 #include <stdio.h>
 #include <stdlib.h>
@@ -50,7 +47,7 @@
 #include "pam_defs.h"
 #include "prototypes.h"

-void do_pam_passwd (const char *user, int silent, int change_expired)
+void do_pam_passwd (const char *user, bool silent, bool change_expired)
 {
 	pam_handle_t *pamh = NULL;
 	int flags = 0, ret;
@@ -76,7 +73,7 @@ void do_pam_passwd (const char *user, int silent, int change_expired)
 	}

 	fputs (_("passwd: password updated successfully\n"), stderr);
-	pam_end (pamh, PAM_SUCCESS);
+	(void) pam_end (pamh, PAM_SUCCESS);
 }
 #else				/* !USE_PAM */
 extern int errno;		/* warning: ANSI C forbids an empty source file */
--- a/libmisc/pam_pass_non_interractive.c
+++ b/libmisc/pam_pass_non_interractive.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2009 - 2010, Nicolas François
+ * 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.
+ * 3. The name of the copyright holders or contributors may not be used to
+ *    endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * HOLDERS 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.
+ */
+
+#include <config.h>
+
+#ident "$Id:$"
+
+#ifdef USE_PAM
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <security/pam_appl.h>
+#include "prototypes.h"
+
+/*@null@*/ /*@only@*/static const char *non_interactive_password = NULL;
+static int ni_conv (int num_msg,
+                    const struct pam_message **msg,
+                    struct pam_response **resp,
+                    unused void *appdata_ptr);
+static struct pam_conv non_interactive_pam_conv = {
+	ni_conv,
+	NULL
+};
+
+
+
+static int ni_conv (int num_msg,
+                    const struct pam_message **msg,
+                    struct pam_response **resp,
+                    unused void *appdata_ptr)
+{
+	struct pam_response *responses;
+	int count;
+
+	assert (NULL != non_interactive_password);
+
+	if (num_msg <= 0) {
+		return PAM_CONV_ERR;
+	}
+
+	responses = (struct pam_response *) calloc ((size_t) num_msg,
+	                                            sizeof (*responses));
+	if (NULL == responses) {
+		return PAM_CONV_ERR;
+	}
+
+	for (count=0; count < num_msg; count++) {
+		responses[count].resp_retcode = 0;
+
+		switch (msg[count]->msg_style) {
+		case PAM_PROMPT_ECHO_ON:
+			fprintf (stderr,
+			         _("%s: PAM modules requesting echoing are not supported.\n"),
+			         Prog);
+			goto failed_conversation;
+		case PAM_PROMPT_ECHO_OFF:
+			responses[count].resp = strdup (non_interactive_password);
+			if (NULL == responses[count].resp) {
+				goto failed_conversation;
+			}
+			break;
+		case PAM_ERROR_MSG:
+			if (   (NULL == msg[count]->msg)
+			    || (fprintf (stderr, "%s\n", msg[count]->msg) <0)) {
+				goto failed_conversation;
+			}
+			responses[count].resp = NULL;
+			break;
+		case PAM_TEXT_INFO:
+			if (   (NULL == msg[count]->msg)
+			    || (fprintf (stdout, "%s\n", msg[count]->msg) <0)) {
+				goto failed_conversation;
+			}
+			responses[count].resp = NULL;
+			break;
+		default:
+			(void) fprintf (stderr,
+			                _("%s: conversation type %d not supported.\n"),
+			                Prog, msg[count]->msg_style);
+			goto failed_conversation;
+		}
+	}
+
+	*resp = responses;
+
+	return PAM_SUCCESS;
+
+failed_conversation:
+	for (count=0; count < num_msg; count++) {
+		if (NULL != responses[count].resp) {
+			memset (responses[count].resp, 0,
+			        strlen (responses[count].resp));
+			free (responses[count].resp);
+			responses[count].resp = NULL;
+		}
+	}
+
+	free (responses);
+	*resp = NULL;
+
+	return PAM_CONV_ERR;
+}
+
+
+/*
+ * Change non interactively the user's password using PAM.
+ *
+ * Return 0 on success, 1 on failure.
+ */
+int do_pam_passwd_non_interractive (const char *pam_service,
+                                    const char *username,
+                                    const char* password)
+{
+	pam_handle_t *pamh = NULL;
+	int ret;
+
+	ret = pam_start (pam_service, username, &non_interactive_pam_conv, &pamh);
+	if (ret != PAM_SUCCESS) {
+		fprintf (stderr,
+		         _("%s: (user %s) pam_start failure %d\n"),
+		         Prog, username, ret);
+		return 1;
+	}
+
+	non_interactive_password = password;
+	ret = pam_chauthtok (pamh, 0);
+	if (ret != PAM_SUCCESS) {
+		fprintf (stderr,
+		         _("%s: (user %s) pam_chauthtok() failed, error:\n"
+		           "%s\n"),
+		         Prog, username, pam_strerror (pamh, ret));
+	}
+
+	(void) pam_end (pamh, PAM_SUCCESS);
+
+	return ((PAM_SUCCESS == ret) ? 0 : 1);
+}
+#else				/* !USE_PAM */
+extern int errno;		/* warning: ANSI C forbids an empty source file */
+#endif				/* !USE_PAM */
--- a/libmisc/pwd2spwd.c
+++ b/libmisc/pwd2spwd.c
@@ -2,7 +2,7 @@
 * Copyright (c) 1989 - 1994, Julianne Frances Haugh
 * Copyright (c) 1996 - 1997, Marek Michałkiewicz
 * Copyright (c) 2003 - 2005, Tomasz Kłoczko
- * Copyright (c) 2007       , Nicolas François
+ * Copyright (c) 2007 - 2009, Nicolas François
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -34,6 +34,8 @@

 #ident "$Id$"

+#ifndef USE_PAM
+
 #include <sys/types.h>
 #include "prototypes.h"
 #include "defines.h"
@@ -64,7 +66,12 @@ struct spwd *pwd_to_spwd (const struct passwd *pw)
 		 */
 		sp.sp_min = 0;
 		sp.sp_max = (10000L * DAY) / SCALE;
-		sp.sp_lstchg = time ((time_t *) 0) / SCALE;
+		sp.sp_lstchg = (long) time ((time_t *) 0) / SCALE;
+		if (0 == sp.sp_lstchg) {
+			/* Better disable aging than requiring a password
+			 * change */
+			sp.sp_lstchg = -1;
+		}
 	}

 	/*
@@ -74,7 +81,11 @@ struct spwd *pwd_to_spwd (const struct passwd *pw)
 	sp.sp_warn = -1;
 	sp.sp_expire = -1;
 	sp.sp_inact = -1;
-	sp.sp_flag = -1;
+	sp.sp_flag = SHADOW_SP_FLAG_UNSET;

 	return &sp;
 }
+#else				/* USE_PAM */
+extern int errno;	/* warning: ANSI C forbids an empty source file */
+#endif				/* !USE_PAM */
+
--- a/Show More
+++ b/Show More