xref: /illumos-gate/usr/src/cmd/logins/logins.c (revision ddb365bfc9e868ad24ccdcb0dc91af18b10df082)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * logins.c
 *
 *	This file contains the source for the administrative command
 *	"logins" (available to the administrator) that produces a report
 *	containing login-IDs and other requested information.
 */

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <grp.h>
#include <pwd.h>
#include <shadow.h>
#include <time.h>
#include <stdarg.h>
#include <fmtmsg.h>
#include <locale.h>

/*
 *  Local constant definitions
 *	TRUE			Boolean constant
 *	FALSE			Boolean constant
 *	USAGE_MSG		Message used to display a usage error
 *	MAXLOGINSIZE		Maximum length of a valid login-ID
 *	MAXSYSTEMLOGIN		Maximum value of a system user-ID.
 *	OPTSTR			Options to this command
 *	ROOT_ID			The user-ID of an administrator
 */

#ifndef	FALSE
#define	FALSE			0
#endif

#ifndef	TRUE
#define	TRUE			((int)'t')
#endif

#define	USAGE_MSG	"usage: logins [-admopstux] [-g groups] [-l logins]"
#define	MAXLOGINSIZE	14
#define	MAXSYSTEMLOGIN	99
#define	OPTSTR		"adg:l:mopstux"
#define	ROOT_ID		0

/*
 *  The following macros do their function for now but will probably have
 *  to be replaced by functions sometime in the near future.  The maximum
 *  system login value may someday be administerable, in which case these
 *  will have to be changed to become functions
 *
 *	isasystemlogin	Returns TRUE if the user-ID in the "struct passwd"
 *			structure referenced by the function's argument is
 *			less than or equal to the maximum value for a system
 *			user-ID, FALSE otherwise.
 *	isauserlogin	Returns TRUE if the user-ID in the "struct passwd"
 *			structure referenced by the function's argument is
 *			greater than the maximum value for a system user-ID,
 *			FALSE otherwise.
 */

#define	isauserlogin(pw)	(pw->pw_uid > MAXSYSTEMLOGIN)
#define	isasystemlogin(pw)	(pw->pw_uid <= MAXSYSTEMLOGIN)


/*
 *  Local datatype definitions
 *	struct reqgrp		Describes a group as requested through the
 *				-g option
 *	struct reqlogin		Describes a login-ID as requested through
 *				the -l option
 *	struct pwdinfo		Describes a password's aging information,
 *				as extracted from /etc/shadow
 *	struct secgrp		Describes a login-ID's secondary group
 */

/*  Describes a specified group name (from the -g groups option)  */
struct	reqgrp {
	char		*groupname;	/* Requested group name */
	struct reqgrp	*next;		/* Next item in the list */
	gid_t		groupID;	/* Group's ID */
};

/*  Describes a specified login name (from the -l logins option)  */
struct	reqlogin {
	char		*loginname;	/* Requested login name */
	struct reqlogin	*next;		/* Next item in the list */
	int		found;		/* TRUE if login in /etc/passwd */
};

/*
 * This structure describes a password's information
 */

struct	pwdinfo {
	long	datechg;	/* Date the password was changed (mmddyy) */
	char	*passwdstatus;	/* Password status */
	long	mindaystilchg;	/* Min days b4 pwd can change again */
	long	maxdaystilchg;	/* Max days b4 pwd can change again */
	long	warninterval;	/* Days before expire to warn user */
	long	inactive;	/* Lapsed days of inactivity before lock */
	long	expdate;	/* Date of expiration (mmddyy) */
};

/* This structure describes secondary groups that a user belongs to */
struct	secgrp {
	char		*groupname;	/* Name of the group */
	struct secgrp	*next;		/* Next item in the list */
	gid_t		groupID;	/* Group-ID */
};


/*
 *  These functions handle error and warning message writing.
 *  (This deals with UNIX(r) standard message generation, so
 *  the rest of the code doesn't have to.)
 *
 *  Functions included:
 *	initmsg		Initialize the message handling functions.
 *	wrtmsg		Write the message using fmtmsg().
 *
 *  Static data included:
 *	fcnlbl		The label for standard messages
 *	msgbuf		A buffer to contain the edited message
 */

static	char	fcnlbl[MM_MXLABELLN+1];	/* Buffer for message label */
static	char	msgbuf[MM_MXTXTLN+1];	/* Buffer for message text */


/*
 * void initmsg(p)
 *
 *	This function initializes the message handling functions.
 *
 *  Arguments:
 *	p	A pointer to a character string that is the name of the
 *		function, used to generate the label on messages.  If this
 *		string contains a slash ('/'), it only uses the characters
 *		beyond the last slash in the string (this permits argv[0]
 *		to be used).
 *
 *  Returns:  Void
 */

static void
initmsg(char *p)
{
	char   *q;	/* Local multi-use pointer */

	/* Use only the simple filename if there is a slash in the name */
	if (!(q = strrchr(p, '/'))) {
		q = p;
	} else {
		q++;
	}

	/* Build the label for messages */
	(void) snprintf(fcnlbl, MM_MXLABELLN, "UX:%s", q);

	/* Restrict messages to the text-component */
	(void) putenv("MSGVERB=text");
}


/*
 *  void wrtmsg(severity, action, tag, text[, txtarg1[, txtarg2[, ...]]])
 *
 *	This function writes a message using fmtmsg()
 *
 *  Arguments:
 *	severity	The severity-component of the message
 *	action		The action-string used to generate the
 *			action-component of the message
 *	tag		Tag-component of the message
 *	text		The text-string used to generate the text-
 *			component of the message
 *	txtarg		Arguments to be inserted into the "text"
 *			string using vsprintf()
 *
 *  Returns:  Void
 */
/*PRINTFLIKE4*/
static void
wrtmsg(int severity, char *action, char *tag, char *text, ...)
{
	int	errorflg;	/* TRUE if problem generating message */
	va_list	argp;		/* Pointer into vararg list */


	/* No problems yet */
	errorflg = FALSE;

	/* Generate the error message */
	va_start(argp, text);
	if (text != MM_NULLTXT) {
		errorflg = vsnprintf(msgbuf,
		    MM_MXTXTLN, text, argp) > MM_MXTXTLN;
	}
	(void) fmtmsg(MM_PRINT, fcnlbl, severity,
	    (text == MM_NULLTXT) ? MM_NULLTXT : msgbuf, action, tag);
	va_end(argp);

	/*
	 *  If there was a buffer overflow generating the error message,
	 *  write a message and quit (things are probably corrupt in the
	 *  static data space now
	 */
	if (errorflg) {
		(void) fmtmsg(MM_PRINT, fcnlbl, MM_WARNING,
		    gettext("Internal message buffer overflow"),
		    MM_NULLACT, MM_NULLTAG);
		exit(100);
	}
}

/*
 *  These functions control the group membership list, as found in
 *  the /etc/group file.
 *
 *  Functions included:
 *	addmember		Adds a member to the membership list
 *	isamember		Looks for a particular login-ID in the
 *				list of members
 *
 *  Datatype Definitions:
 *	struct grpmember	Describes a group member
 *
 *  Static Data:
 *	membershead		Pointer to the head of the list of
 *				group members
 */

struct	grpmember {
	char			*membername;
	struct grpmember	*next;
};

static	struct grpmember	*membershead;

/*
 *  void addmember(p)
 *	char   *p
 *
 *	This function adds a member to the group member's list.  The
 *	group members list is a list of structures containing a pointer
 *	to the member-name and a pointer to the next item in the
 *	structure.  The structure is not ordered in any particular way.
 *
 *  Arguments:
 *	p	Pointer to the member name
 *
 *  Returns:  Void
 */

static void
addmember(char *p)
{
	struct grpmember	*new;	/* Member being added */

	new = malloc(sizeof (struct grpmember));
	new->membername = strdup(p);
	new->next = membershead;
	membershead = new;
}


/*
 *  init isamember(p)
 *	char   *p
 *
 *	This function examines the list of group-members for the string
 *	referenced by 'p'.  If 'p' is a member of the members list, the
 *	function returns TRUE.  Otherwise it returns FALSE.
 *
 *  Arguments:
 *	p	Pointer to the name to search for.
 *
 *  Returns:  int
 *	TRUE	If 'p' is found in the members list,
 *	FALSE	otherwise
 */

static int
isamember(char *p)
{
	int			found;	/* TRUE if login found in list */
	struct grpmember	*pmem;	/* Group member being examined */


	/* Search the membership list for 'p' */
	found = FALSE;
	for (pmem = membershead; !found && pmem; pmem = pmem->next) {
		if (strcmp(p, pmem->membername) == 0)
			found = TRUE;
	}

	return (found);
}


/*
 *  These functions handle the display list.  The display list contains
 *  all of the information we're to display.  The list contains a pointer
 *  to the login-name, a pointer to the free-field (comment), and a
 *  pointer to the next item in the list.  The list is ordered alpha-
 *  betically (ascending) on the login-name field.  The list initially
 *  contains a dummy field (to make insertion easier) that contains a
 *  login-name of "".
 *
 *  Functions included:
 *	initdisp	Initializes the display list
 *	adddisp		Adds information to the display list
 *	isuidindisp	Looks to see if a particular user-ID is in the
 *			display list
 *	genreport	Generates a report from the items in the display
 *			list
 *	applygroup	Add group information to the items in the display
 *			list
 *	applypasswd	Add extended password information to the items
 *			in the display list
 *
 *  Datatypes Defined:
 *	struct display	Describes the structure that contains the information
 *			to be displayed.  Includes pointers to the login-ID,
 *			free-field (comment), and the next structure in the
 *			list.
 *
 *  Static Data:
 *	displayhead	Pointer to the head of the display list.  Initially
 *			references the null-item on the head of the list.
 */

struct	display {
	char		*loginID;	/* Login name */
	char		*freefield;	/* Free (comment) field */
	char		*groupname;	/* Name of the primary group */
	char		*iwd;		/* Initial working directory */
	char		*shell;		/* Shell after login (may be null) */
	struct pwdinfo	*passwdinfo;	/* Password information structure */
	struct secgrp 	*secgrplist; 	/* Head of the secondary group list */
	uid_t		userID;		/* User ID */
	gid_t		groupID;	/* Group ID of primary group */
	struct display	*nextlogin;	/* Next login in the list */
	struct display	*nextuid;	/* Next user-ID in the list */
};

static	struct display	*displayhead;


/*
 *  void initdisp()
 *
 *	Initializes the display list.  An empty display list contains
 *	a single element, the dummy element.
 *
 *  Arguments:  None
 *
 *  Returns:  Void
 */

static void
initdisp(void)
{
	displayhead = malloc(sizeof (struct display));
	displayhead->nextlogin = NULL;
	displayhead->nextuid = NULL;
	displayhead->loginID = "";
	displayhead->freefield = "";
	displayhead->userID = (uid_t)-1;
}


/*
 *  void adddisp(pwent)
 *	struct passwd  *pwent
 *
 *	This function adds the appropriate information from the login
 *	description referenced by 'pwent' to the list if information
 *	to be displayed.  It only adds the information if the login-ID
 *	(user-name) is unique.  It inserts the information in the list
 *	in such a way that the list remains ordered alphabetically
 *	(ascending) according to the login-ID (user-name).
 *
 *  Arguments:
 *	pwent		Structure that contains all of the login information
 *			of the login being added to the list.  The only
 *			information that this function uses is the login-ID
 *			(user-name) and the free-field (comment field).
 *
 *  Returns:  Void
 */

static void
adddisp(struct passwd *pwent)
{
	struct display *new;		/* Item being added to the list */
	struct display *prev;		/* Previous item in the list */
	struct display *current;	/* Next item in the list */
	int		found;		/* FLAG, insertion point found */
	int		compare = 1;	/* strcmp() compare value */


	/* Find where this value belongs in the list */
	prev = displayhead;
	found = FALSE;
	while (!found && (current = prev->nextlogin)) {
		if ((compare = strcmp(current->loginID, pwent->pw_name)) >= 0) {
			found = TRUE;
		} else {
			prev = current;
		}

	}
	/* Insert this value in the list, only if it is unique though */
	if (compare != 0) {
		new = malloc(sizeof (struct display));
		new->loginID = strdup(pwent->pw_name);
		if (pwent->pw_comment && pwent->pw_comment[0] != '\0') {
			new->freefield = strdup(pwent->pw_comment);
		} else {
		    new->freefield = strdup(pwent->pw_gecos);
		}
		if (!pwent->pw_shell || !(*pwent->pw_shell)) {
			new->shell = "/sbin/sh";
		} else {
			new->shell = strdup(pwent->pw_shell);
		}
		new->iwd = strdup(pwent->pw_dir);
		new->userID = pwent->pw_uid;
		new->groupID = pwent->pw_gid;
		new->secgrplist = NULL;
		new->passwdinfo = NULL;
		new->groupname = NULL;

		/* Add new display item to the list ordered by login-ID */
		new->nextlogin = current;
		prev->nextlogin = new;

		/*
		 * Find the appropriate place for the new item in the list
		 * ordered by userID
		 */
		prev = displayhead;
		found = FALSE;
		while (!found && (current = prev->nextuid)) {
			if (current->userID > pwent->pw_uid) {
				found = TRUE;
			} else {
				prev = current;
			}
		}

		/* Add the item into the list that is ordered by user-ID */
		new->nextuid = current;
		prev->nextuid = new;
	}
}


/*
 *  int isuidindisp(pwent)
 *	struct passwd  *pwent
 *
 *  This function examines the display list to see if the uid in
 *  the (struct passwd) referenced by "pwent" is already in the
 *  display list.  It returns TRUE if it is in the list, FALSE
 *  otherwise.
 *
 *  Since the display list is ordered by user-ID, the search continues
 *  until a match is found or a user-ID is found that is larger than
 *  the one we're searching for.
 *
 *  Arguments:
 *	pwent		Structure that contains the user-ID we're to
 *			look for
 *
 *  Returns:  int
 *	TRUE if the user-ID was found, FALSE otherwise.
 */

static int
isuidindisp(struct passwd *pwent)
{
	struct display *dp;


	/*
	 *  Search the list, beginning at the beginning (where else?)
	 *  and stopping when the user-ID is found or one is found that
	 *  is greater than the user-ID we're searching for.  Recall
	 *  that this list is ordered by user-ID
	 */

	for (dp = displayhead->nextuid; dp && (dp->userID < pwent->pw_uid);
	    dp = dp->nextuid) {
		continue;
	}

	/*
	 * If the pointer "dp" points to a structure that has a
	 * matching user-ID, return TRUE.  Otherwise FALSE
	 */
	return (dp && (dp->userID == pwent->pw_uid));
}


/*
 *  void applygroup(allgroups)
 *	int	allgroups
 *
 *  This function applies group information to the login-IDs in the
 *  display list.  It always applies the primary group information.
 *  If "allgroups" is TRUE, it applies secondary information as well.
 *
 *  Arguments:
 * 	allgroups	FLAG.  TRUE if secondary group info is to be
 *			applied -- FALSE otherwise.
 *
 *  Returns:  void
 */

static void
applygroup(int allgroups)
{
	struct display	*dp;		/* Display list running ptr */
	struct group	*grent;		/* Group info, from getgrent() */
	char		*p;		/* Temp char pointer */
	char		**pp;		/* Temp char * pointer */
	int		compare;	/* Value from strcmp() */
	int		done;		/* TRUE if finished, FALSE otherwise */
	struct secgrp	*psecgrp;	/* Block allocated for this info */
	struct secgrp	*psrch;		/* Secondary group -- for searching */

	if (!allgroups) {
		/* short circute getting all the groups */
		for (dp = displayhead->nextuid; dp; dp = dp->nextuid) {
			if ((grent = getgrgid(dp->groupID)) != NULL) {
				dp->groupname = strdup(grent->gr_name);
			}
		}
		return;
	}

	/* For each group-ID in the /etc/group file ... */
	while (grent = getgrent()) {
		/*
		 *  Set the primary group for the login-IDs in the display
		 *  list.  For each group-ID we get, leaf through the display
		 *  list and set the group-name if the group-IDs match
		 */

		p = NULL;
		for (dp = displayhead->nextuid; dp; dp = dp->nextuid) {
			if ((dp->groupID == grent->gr_gid) && !dp->groupname) {
				if (!p) {
					p = strdup(grent->gr_name);
				}
				dp->groupname = p;
			}
		}

		/*
		 *  If we're to be displaying secondary group membership,
		 *  leaf through the list of group members.  Then, attempt
		 *  to find that member in the display list.  When found,
		 *  attach secondary group info to the user.
		 */

		for (pp = grent->gr_mem; *pp; pp++) {
			done = FALSE;
			for (dp = displayhead->nextlogin; !done && dp;
			    dp = dp->nextlogin) {
				if (((compare = strcmp(dp->loginID,
				    *pp)) == 0) &&
				    !(grent->gr_gid == dp->groupID)) {
					if (!p) {
						p = strdup(grent->gr_name);
					}
					psecgrp = malloc(
					    sizeof (struct secgrp));
					psecgrp->groupID = grent->gr_gid;
					psecgrp->groupname = p;
					psecgrp->next = NULL;
					if (!dp->secgrplist) {
						dp->secgrplist = psecgrp;
					} else {
						for (psrch = dp->secgrplist;
						    psrch->next;
						    psrch = psrch->next) {
							continue;
						}
						psrch->next = psecgrp;
					}
					done = TRUE;
				} else if (compare > 0) {
						done = TRUE;
				}
			}
		}
	}

	/* Close the /etc/group file */
	endgrent();
}


/*
 *  void applypasswd()
 *
 *	This function applies extended password information to an item
 *	to be displayed.  It allocates space for a structure describing
 *	the password, then fills in that structure from the information
 *	in the /etc/shadow file.
 *
 *  Arguments:  None
 *
 *  Returns:  Void
 */

static void
applypasswd(void)
{
	struct pwdinfo	*ppasswd;	/* Ptr to pwd desc in current element */
	struct display	*dp;		/* Ptr to current element */
	struct spwd	*psp;		/* Pointer to a shadow-file entry */
	struct tm	*ptm;		/* Pointer to a time-of-day structure */
	time_t		pwchg;		/* System-time of last pwd chg */
	time_t		pwexp;		/* System-time of password expiration */


	/*  Make sure the shadow file is rewound  */
	setspent();


	/*
	 *  For each item in the display list...
	 */

	for (dp = displayhead->nextuid; dp; dp = dp->nextuid) {

		/* Allocate structure space for the password description */
		ppasswd = malloc(sizeof (struct pwdinfo));
		dp->passwdinfo = ppasswd;

		/*
		 * If there's no entry in the /etc/shadow file, assume
		 * that the login is locked
		 */

		if ((psp = getspnam(dp->loginID)) == NULL) {
			pwchg = 0L;			/* Epoch */
			ppasswd->passwdstatus = "LK";	/* LK, Locked */
			ppasswd->mindaystilchg = 0L;
			ppasswd->maxdaystilchg = 0L;
			ppasswd->warninterval = 0L;
			ppasswd->inactive = 0L;
			pwexp = 0L;
		} else {
			/*
			 * Otherwise, fill in the password information from the
			 * info in the shadow entry
			 */
			if (psp->sp_pwdp == NULL || (*psp->sp_pwdp) == '\0')
				ppasswd->passwdstatus = "NP";
			else if (strncmp(psp->sp_pwdp, LOCKSTRING,
			    sizeof (LOCKSTRING)-1) == 0)
				ppasswd->passwdstatus = "LK";
			else if (strncmp(psp->sp_pwdp, NOLOGINSTRING,
			    sizeof (NOLOGINSTRING)-1) == 0)
				ppasswd->passwdstatus = "NL";
			else if ((strlen(psp->sp_pwdp) == 13 &&
			    psp->sp_pwdp[0] != '$') ||
			    psp->sp_pwdp[0] == '$')
				ppasswd->passwdstatus = "PS";
			else
				ppasswd->passwdstatus = "UN";
			/*
			 * Set up the last-changed date,
			 * the minimum days between changes,
			 * the maximum life of a password,
			 * the interval before expiration that the user
			 * is warned,
			 * the number of days a login can be inactive before
			 * it expires, and the login expiration date
			 */

			pwchg = psp->sp_lstchg;
			ppasswd->mindaystilchg = psp->sp_min;
			ppasswd->maxdaystilchg = psp->sp_max;
			ppasswd->warninterval = psp->sp_warn;
			ppasswd->inactive = psp->sp_inact;
			pwexp = psp->sp_expire;
		}

		/*
		 * Convert the date of the last password change from days-
		 * since-epoch to mmddyy (integer) form.  Involves the
		 * intermediate step of converting the date from days-
		 * since-epoch to seconds-since-epoch.  We'll set this to
		 * somewhere near the middle of the day, since there are not
		 * always 24*60*60 seconds in a year.  (Yeech)
		 *
		 * Note:  The form mmddyy should probably be subject to
		 * internationalization -- Non-Americans will think that
		 * 070888 is 07 August 88 when the software is trying to say
		 * 08 July 88.  Systems Engineers seem to think that this isn't
		 * a problem though...
		 */

		if (pwchg != -1L) {
			pwchg = (pwchg * DAY) + (DAY/2);
			ptm = localtime(&pwchg);
			ppasswd->datechg = ((long)(ptm->tm_mon+1) * 10000L) +
			    (long)((ptm->tm_mday * 100) +
			    (ptm->tm_year % 100));
		} else {
			ppasswd->datechg = 0L;
		}

		/*
		 * Convert the passwd expiration date from days-since-epoch
		 * to mmddyy (long integer) form using the same algorithm and
		 * comments as above.
		 */

		if (pwexp != -1L) {
			pwexp = (pwexp * DAY) + (DAY/2);
			ptm = localtime(&pwexp);
			ppasswd->expdate = ((long)(ptm->tm_mon+1) * 10000L) +
			    (long)((ptm->tm_mday * 100) +
			    (ptm->tm_year % 100));
		} else {
			ppasswd->expdate = 0L;
		}
	}

	/* Close the shadow password file */
	endspent();
}


/*
 * int hasnopasswd(pwent)
 *	struct passwd  *pwent
 *
 *	This function examines a login's password-file entry
 *	and, if necessary, its shadow password-file entry and
 *	returns TRUE if that user-ID has no password, meaning
 *	that the user-ID can be used to log into the system
 *	without giving a password.  The function returns FALSE
 *	otherwise.
 *
 *  Arguments:
 *	pwent	Login to examine.
 *
 *  Returns:  int
 *	TRUE if the login can be used without a password, FALSE
 *	otherwise.
 */

static int
hasnopasswd(struct passwd *pwent)
{
	struct spwd    *psp;		/* /etc/shadow file struct */
	int		nopwflag;	/* TRUE if login has no passwd */

	/*
	 *  A login has no password if:
	 *    1.  There exists an entry for that login in the
	 *	  shadow password-file (/etc/passwd), and
	 *    2.  The encrypted password in the structure describing
	 *	  that entry is either:	 NULL or a null string ("")
	 */

	/* Get the login's entry in the shadow password file */
	if (psp = getspnam(pwent->pw_name)) {

		/* Look at the encrypted password in that entry */
		if (psp->sp_pwdp == (char *)0 ||
		    *psp->sp_pwdp == '\0') {
			nopwflag = TRUE;
		} else {
			nopwflag = FALSE;
		}
	} else {
		nopwflag = FALSE;
	}

	/* Done ... */
	return (nopwflag);
}


/*
 *  void writeunformatted(current, xtndflag, expflag)
 *	struct display *current
 *	int		xtndflag
 *	int		expflag
 *
 *  This function writes the data in the display structure "current"
 *  to the standard output file.  It writes the information in the
 *  form of a colon-list.  It writes secondary group information if
 *  that information is in the structure, it writes extended
 *  (initial working directory, shell, and password-aging) info
 *  if the "xtndflag" is TRUE, and it writes password expiration
 *  information if "expflag" is TRUE.
 *
 *  Arguments:
 *	current		Structure containing information to write.
 *	xtndflag	TRUE if extended information is to be written,
 *			FALSE otherwise
 *	expflag		TRUE if password expiration information is to
 *			be written, FALSE otherwise
 *
 *  Returns:  void
 */

static void
writeunformatted(struct display *current, int xtndflag, int expflag)
{
	struct secgrp  *psecgrp;	/* Secondary group info */
	struct pwdinfo *pwdinfo;	/* Password aging info */

	/* Write the general information */
	(void) fprintf(stdout, "%s:%u:%s:%u:%s",
	    current->loginID,
	    current->userID,
	    current->groupname == NULL ? "" : current->groupname,
	    current->groupID,
	    current->freefield);

	/*
	 * If the group information is there, write it (it's only
	 * there if it's supposed to be written)
	 */
	for (psecgrp = current->secgrplist; psecgrp; psecgrp = psecgrp->next) {
		(void) fprintf(stdout, ":%s:%u",
		    psecgrp->groupname, psecgrp->groupID);
	}

	/* If the extended info flag is TRUE, write the extended information */
	if (xtndflag) {
		pwdinfo = current->passwdinfo;
		(void) fprintf(stdout, ":%s:%s:%s:%6.6ld:%ld:%ld:%ld",
		    current->iwd, current->shell,
		    pwdinfo->passwdstatus,
		    pwdinfo->datechg,
		    pwdinfo->mindaystilchg, pwdinfo->maxdaystilchg,
		    pwdinfo->warninterval);
	}

	/* If the password expiration information is requested, write it.  */
	if (expflag) {
		pwdinfo = current->passwdinfo;
		(void) fprintf(stdout, ":%ld:%ld",
		    pwdinfo->inactive, pwdinfo->expdate);
	}

	/* Terminate the information with a new-line */
	(void) putc('\n', stdout);
}


/*
 *  void writeformatted(current, xtndflag, expflag)
 *	struct display *current
 *	int		xtndflag
 *	int		expflag
 *
 *  This function writes the data in the display structure "current"
 *  to the standard output file.  It writes the information in an
 *  easily readable format.  It writes secondary group information
 *  if that information is in the structure, it writes extended
 *  (initial working directory, shell, and password-aging) info if
 *  "xtndflag" is TRUE, and it write password expiration information
 *  if "expflag" is TRUE.
 *
 *  Arguments:
 *	current		Structure containing info to write.
 *	xtndflag	TRUE if extended information to be written,
 *			FALSE otherwise
 *	expflag 	TRUE if password expiration information to be written,
 *			FALSE otherwise
 *
 *  Returns:  void
 */

static void
writeformatted(struct display *current, int xtndflag, int expflag)
{
	struct secgrp  *psecgrp;	/* Secondary group info */
	struct pwdinfo *pwdinfo;	/* Password aging info */

	/* Write general information */
	(void) fprintf(stdout, "%-14s  %-6u  %-14s  %-6u  %s\n",
	    current->loginID, current->userID,
	    current->groupname == NULL ? "" : current->groupname,
	    current->groupID, current->freefield);

	/*
	 * Write information about secondary groups if the info exists
	 * (it only exists if it is to be written)
	 */
	for (psecgrp = current->secgrplist; psecgrp; psecgrp = psecgrp->next) {
	    (void) fprintf(stdout, "                        %-14s  %-6u\n",
		psecgrp->groupname, psecgrp->groupID);
	}

	/*
	 * If the extended information flag is TRUE,
	 * write the extended information
	 */

	if (xtndflag) {
		pwdinfo = current->passwdinfo;
		(void) fprintf(stdout, "                        %s\n",
		    current->iwd);
		(void) fprintf(stdout, "                        %s\n",
		    current->shell);
		(void) fprintf(stdout, "                        %s "
		    "%6.6ld %ld %ld %ld\n",
		    pwdinfo->passwdstatus,
		    pwdinfo->datechg, pwdinfo->mindaystilchg,
		    pwdinfo->maxdaystilchg,
		    pwdinfo->warninterval);
	}

	/*
	 * If the password expiration info flag is TRUE,
	 * write that information
	 */
	if (expflag) {
		pwdinfo = current->passwdinfo;
		(void) fprintf(stdout, "                        %ld %6.6ld\n",
		    pwdinfo->inactive, pwdinfo->expdate);
	}
}


/*
 *  void genuidreport(pipeflag, xtndflag, expflag)
 *	int	pipeflag
 *	int	xtndflag
 *	int	expflag
 *
 *	This function generates a report on the standard output
 *	stream (stdout) containing the login-IDs in the list of
 *	logins built by this command.  The list is ordered based
 *	on user-ID.  If the <pipeflag> variable is not zero, it
 *	will generate a report containing parsable records.
 *	Otherwise, it will generate a columnarized report.  If
 *	the <xtndflag> variable is not zero, it will include the
 *	extended set of information (password aging info, home
 *	directory, shell process, etc.).  If <expflag> is not
 *	zero, it will display password expiration information.
 *
 *  Arguments:
 *	pipeflag	int
 *			TRUE if a parsable report is needed,
 *			FALSE if a columnar report is needed
 *	xtndflag	int
 *			TRUE if extended set of info is to be displayed,
 *			FALSE otherwise
 *	expflag		int
 *			TRUE if password expiration information is to be
 *			displayed, FALSE otherwise
 *
 *  Returns:  void
 */

static void
genuidreport(int pipeflag, int xtndflag, int expflag)
{

	struct display *current;	/* Data being displayed */


	/*
	 *  Initialization for loop.
	 *  (NOTE:  The first element in the list of logins to	display is
	 *  a dummy element.)
	 */
	current = displayhead;

	/*
	 *  Display elements in the list
	 */
	if (pipeflag) {
		for (current = displayhead->nextuid; current;
		    current = current->nextuid) {
			writeunformatted(current, xtndflag, expflag);
		}
	} else {
		for (current = displayhead->nextuid; current;
		    current = current->nextuid) {
			writeformatted(current, xtndflag, expflag);
		}
	}
}


/*
 *  void genlogreport(pipeflag, xtndflag, expflag)
 *	int	pipeflag
 *	int	xtndflag
 *	int	expflag
 *
 *	This function generates a report on the standard output
 *	stream (stdout) containing the login-IDs in the list of
 *	logins built by this command.  The list is ordered based
 *	on user name.  If the <pipeflag> variable is not zero, it
 *	will generate a report containing parsable records.
 *	Otherwise, it will generate a columnarized report.  If
 *	the <xtndflag> variable is not zero, it will include the
 *	extended set of information (password aging info, home
 *	directory, shell process, etc.).  If <expflag> is not
 *	zero, it will include password expiration information.
 *
 *  Arguments:
 *	pipeflag	int
 *			TRUE if a parsable report is needed,
 *			FALSE if a columnar report is needed
 *	xtndflag	int
 *			TRUE if extended set of info is to be displayed,
 *			FALSE otherwise
 *	expflag		int
 *			TRUE if password expiration information is to
 *			be displayed, FALSE otherwise
 *
 *  Returns:  void
 */

static void
genlogreport(int pipeflag, int xtndflag, int expflag)
{
	struct display *p;	/* Value being displayed */


	/*
	 *  Initialization for loop.
	 *  (NOTE:  The first element in the list of logins to display is
	 *  a dummy element.)
	 */
	p = displayhead;

	/*
	 *  Display elements in the list
	 */
	if (pipeflag) {
		for (p = displayhead->nextlogin; p; p = p->nextlogin) {
			writeunformatted(p, xtndflag, expflag);
		}
	} else {
		for (p = displayhead->nextlogin; p; p = p->nextlogin) {
			writeformatted(p, xtndflag, expflag);
		}
	}
}

struct localpw {
	struct localpw *next;
	struct passwd pw;
};

struct localpw *pwtable = NULL;

/* Local passwd pointer for getpwent() -- -1 means not in use, NULL for EOF */
struct localpw *pwptr;

int in_localgetpwent = 0;	/* Set if in local_getpwent */

static struct localpw *
fill_localpw(struct localpw *lpw, struct passwd *pw) {
	struct localpw *cur;

	/*
	 * Copy the data -- we have to alloc areas for it all
	 */
	lpw->pw.pw_name = strdup(pw->pw_name);
	lpw->pw.pw_passwd = strdup(pw->pw_passwd);
	lpw->pw.pw_uid = pw->pw_uid;
	lpw->pw.pw_gid = pw->pw_gid;
	lpw->pw.pw_age = strdup(pw->pw_age);
	lpw->pw.pw_comment = strdup(pw->pw_comment);
	lpw->pw.pw_gecos  = strdup(pw->pw_gecos);
	lpw->pw.pw_dir = strdup(pw->pw_dir);
	lpw->pw.pw_shell = strdup(pw->pw_shell);

	cur = lpw;
	lpw->next = malloc(sizeof (struct localpw));
	return (cur);
}

void
build_localpw(struct reqlogin *req_head)
{
	struct localpw *next, *cur;
	struct passwd *pw;
	struct reqlogin *req_next;

	next = malloc(sizeof (struct localpw));

	pwtable = next;

	req_next = req_head;

	while (req_next != NULL) {
		if ((pw = getpwnam(req_next->loginname)) != NULL) {
			/*
			 * Copy the data -- we have to alloc areas for it all
			 */
			cur = fill_localpw(next, pw);
			req_next->found = TRUE;
			next = cur->next;
		}

		req_next = req_next->next;
	}

	if (req_head == NULL) {
		while ((pw = getpwent()) != NULL) {
			/*
			 * Copy the data -- we have to alloc areas for it all
			 */
			cur = fill_localpw(next, pw);
			next = cur->next;
		}
	}

	if (pwtable == next) {
		pwtable = NULL;
	} else {
		free(next);
		cur->next = NULL;
	}

	endpwent();
}

struct passwd *
local_getpwent(void)
{
	if (!in_localgetpwent) {
		in_localgetpwent = 1;
		pwptr = pwtable;
	} else if (pwptr != NULL) {
		pwptr = pwptr->next;
	}

	if (pwptr != NULL)
		return (&(pwptr->pw));
	else
		return (NULL);
}

void
local_endpwent(void)
{
	in_localgetpwent = 0;
}

long
local_pwtell(void)
{
	return ((long)pwptr);
}

void
local_pwseek(long ptr)
{
	pwptr = (struct localpw *)ptr;
}

/*
 * logins [-admopstux] [-l logins] [-g groups]
 *
 *	This command generates a report of logins administered on
 *	the system.  The list will contain logins that meet criteria
 *	described by the options in the list.  If there are no options,
 *	it will list all logins administered.  It is intended to be used
 *	only by administrators.
 *
 *  Options:
 *	-a		Display password expiration information.
 *	-d		list all logins that share user-IDs with another
 *			login.
 *	-g groups	specifies the names of the groups to which a login
 *			must belong before it is included in the generated
 *			list.  "groups" is a comma-list of group names.
 *	-l logins	specifies the logins to display.  "logins" is a
 *			comma-list of login names.
 *	-m		in addition to the usual information, for each
 *			login displayed, list all groups to which that
 *			login is member.
 *	-o		generate a report as a colon-list instead of in a
 *			columnar format
 *	-p		list all logins that have no password.
 *	-s		list all system logins
 *	-t		sort the report lexicographically by login name
 *			instead of by user-ID
 *	-u		list all user logins
 *	-x		in addition to the usual information, display an
 *			extended set of information that includes the home
 *			directory, initial process, and password status and
 *			aging information
 *
 * Exit Codes:
 *	0	All's well that ends well
 *	1	Usage error
 */

int
main(int argc, char *argv[])
{
	struct passwd	*plookpwd;	/* Ptr to searcher pw (-d) */
	struct reqgrp	*reqgrphead;	/* Head of the req'd group list */
	struct reqgrp	*pgrp;		/* Current item in req'd group list */
	struct reqgrp	*qgrp;		/* Prev item in the req'd group list */
	struct reqlogin *reqloginhead;	/* Head of req'd login list */
	struct reqlogin *plogin;	/* Current item in req'd login list */
	struct reqlogin *qlogin;	/* Prev item in req'd login list */
	struct passwd	*pwent;		/* /etc/passwd entry */
	struct group	*grent;		/* /etc/group entry */
	char		*token;		/* Token extracted by strtok() */
	char		**pp;		/* Group member */
	char		*g_arg;		/* -g option's argument */
	char		*l_arg;		/* -l option's argument */
	long		lookpos;	/* File pos'n, rec we're looking for */
	int		a_seen;		/* Is -a requested? */
	int		d_seen;		/* Is -d requested? */
	int		g_seen;		/* Is -g requested? */
	int		l_seen;		/* Is -l requested? */
	int		m_seen;		/* Is -m requested? */
	int		o_seen;		/* Is -o requested? */
	int		p_seen;		/* Is -p requested? */
	int		s_seen;		/* Is -s requested? */
	int		t_seen;		/* Is -t requested? */
	int		u_seen;		/* Is -u requested? */
	int		x_seen;		/* Is -x requested? */
	int		errflg;		/* Is there a command-line problem */
	int		done;		/* Is the process (?) is complete */
	int		groupcount;	/* Number of groups specified */
	int		doall;		/* Are all logins to be reported */
	int		c;		/* Character returned from getopt() */

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	/* Initializations */
	initmsg(argv[0]);



	/*  Command-line processing */

	/* Initializations */
	a_seen = FALSE;
	d_seen = FALSE;
	g_seen = FALSE;
	l_seen = FALSE;
	m_seen = FALSE;
	o_seen = FALSE;
	p_seen = FALSE;
	s_seen = FALSE;
	t_seen = FALSE;
	u_seen = FALSE;
	x_seen = FALSE;
	errflg = FALSE;
	opterr = 0;
	while (!errflg && ((c = getopt(argc, argv, OPTSTR)) != EOF)) {

		/* Case on the option character */
		switch (c) {

		/*
		 * -a option:
		 * Display password expiration information
		 */

		case 'a':
			if (a_seen)
				errflg = TRUE;
			else
				a_seen = TRUE;
			break;

		/*
		 * -d option:
		 * Display logins which share user-IDs with other logins
		 */

		case 'd':
			if (d_seen)
				errflg = TRUE;
			else
				d_seen = TRUE;
			break;

		/*
		 * -g <groups> option:
		 * Display the specified groups
		 */

		case 'g':
			if (g_seen) {
				errflg = TRUE;
			} else {
				g_seen = TRUE;
				g_arg = optarg;
			}
			break;

		/*
		 * -l <logins> option:
		 * Display the specified logins
		 */

		case 'l':
			if (l_seen) {
				errflg = TRUE;
			} else {
				l_seen = TRUE;
				l_arg = optarg;
			}
			break;

		/*
		 * -m option:
		 * Display multiple group information
		 */

		case 'm':
			if (m_seen)
				errflg = TRUE;
			else
				m_seen = TRUE;
			break;

		/*
		 * -o option:
		 * Display information as a colon-list
		 */

		case 'o':
			if (o_seen)
				errflg = TRUE;
			else
				o_seen = TRUE;
			break;

		/*
		 * -p option:
		 * Select logins that have no password
		 */

		case 'p':
			if (p_seen)
				errflg = TRUE;
			else
				p_seen = TRUE;
			break;

		/*
		 * -s option:
		 * Select system logins
		 */

		case 's':
			if (s_seen)
				errflg = TRUE;
			else
				s_seen = TRUE;
			break;

		/*
		 * -t option:
		 * Sort alphabetically by login-ID instead of numerically
		 * by user-ID
		 */

		case 't':
			if (t_seen)
				errflg = TRUE;
			else
				t_seen = TRUE;
			break;

		/*
		 * -u option:
		 * Select user logins
		 */

		case 'u':
			if (u_seen)
				errflg = TRUE;
			else
				u_seen = TRUE;
			break;

		/*
		 * -x option:
		 * Display extended info (init working dir, shell, pwd info)
		 */

		case 'x':
			if (x_seen)
				errflg = TRUE;
			else
				x_seen = TRUE;
			break;

		default:		/* Oops.... */
			errflg = TRUE;
		}
	}

	/* Write out a usage message if necessary and quit */
	if (errflg || (optind != argc)) {
		wrtmsg(MM_ERROR, MM_NULLACT, MM_NULLTAG, gettext(USAGE_MSG));
		exit(1);
	}

	/*
	 *  The following section does preparation work, setting up for
	 *  building the list of logins to display
	 */


	/*
	 *  If -l logins is on the command line, build a list of
	 *  logins we're to generate reports for.
	 */

	if (l_seen) {
		reqloginhead = NULL;
		if (token = strtok(l_arg, ",")) {
			plogin = malloc(sizeof (struct reqlogin));
			plogin->loginname = token;
			plogin->found = FALSE;
			plogin->next = NULL;
			reqloginhead = plogin;
			qlogin = plogin;
			while (token = strtok(NULL, ",")) {
				plogin = malloc(sizeof (struct reqlogin));
				plogin->loginname = token;
				plogin->found = FALSE;
				plogin->next = NULL;
				qlogin->next = plogin;
				qlogin = plogin;
			}
		}
		/*
		 * Build an in-core structure of just the passwd database
		 * entries requested.  This greatly reduces the time
		 * to get all entries and filter later.
		 */
		build_localpw(reqloginhead);
	} else {
		/*
		 * Build an in-core structure of all passwd database
		 * entries.  This is important since we have to assume that
		 * getpwent() is going out to one or more network name
		 * services that could be changing on the fly.  This will
		 * limit us to one pass through the network data.
		 */
		build_localpw(NULL);
	}

	/*
	 *  If the -g groups option was on the command line, build a
	 *  list containing groups we're to list logins for.
	 */

	if (g_seen) {
		groupcount = 0;
		reqgrphead = NULL;
		if (token = strtok(g_arg, ",")) {
			pgrp = malloc(sizeof (struct reqgrp));
			pgrp->groupname = token;
			pgrp->next = NULL;
			groupcount++;
			reqgrphead = pgrp;
			qgrp = pgrp;
			while (token = strtok(NULL, ",")) {
				pgrp = malloc(sizeof (struct reqgrp));
				pgrp->groupname = token;
				pgrp->next = NULL;
				groupcount++;
				qgrp->next = pgrp;
				qgrp = pgrp;
			}
		}
	}


	/*
	 *  Generate the list of login information to display
	 */

	/* Initialize the login list */
	membershead = NULL;


	/*
	 *  If -g groups was specified, generate a list of members
	 *  of the specified groups
	 */

	if (g_seen) {
		/* For each group mentioned with the -g option ... */
		for (pgrp = reqgrphead; (groupcount > 0) && pgrp;
		    pgrp = pgrp->next) {
			if ((grent = getgrnam(pgrp->groupname)) != NULL) {
				/*
				 * Remembering the group-ID for later
				 */

				groupcount--;
				pgrp->groupID = grent->gr_gid;
				for (pp = grent->gr_mem; *pp; pp++) {
					addmember(*pp);
				}
			} else {
				wrtmsg(MM_WARNING, MM_NULLACT, MM_NULLTAG,
				    gettext("%s was not found"),
				    pgrp->groupname);
			}
		}
	}


	/* Initialize the list of logins to display */
	initdisp();


	/*
	 *  Add logins that have user-IDs that are used more than once,
	 *  if requested.  This command is pretty slow, since the algorithm
	 *  reads from the /etc/passwd file 1+2+3+...+n times where n is the
	 *  number of login-IDs in the /etc/passwd file.  (Actually, this
	 *  can be optimized so it's not quite that bad, but the order or
	 *  magnitude stays the same.)
	 *
	 *  Note:  This processing needs to be done before any other options
	 *	   are processed -- the algorithm contains an optimization
	 *	   that insists on the display list being empty before this
	 *	   option is processed.
	 */

	if (d_seen) {

		/*
		 * The following code is a quick&dirty reimplementation of the
		 * original algorithm, which opened the password file twice (to
		 * get two file pointer into the data) and then used fgetpwent()
		 * in undocumented ways to scan through the file, checking for
		 * duplicates.  This does not work when getpwent() is used to
		 * go out over the network, since there is not file pointer.
		 *
		 * Instead an in-memory list of passwd structures is built,
		 * and then this list is scanned.  The routines
		 * Local_getpwent(), etc., are designed to mimic the standard
		 * library routines, so this code does not have to be
		 * extensively modified.
		 */

		/*
		 * For reference, here is the original comment about the next
		 * section of code.  Some of the code has changed, but the
		 * algorithm is the same:
		 *
		 * Open the system password file once.  This instance will be
		 * used to leaf through the file once, reading each entry once,
		 * and searching the remainder of the file for another login-ID
		 * that has the same user-ID.  Note that there are lots of
		 * contortions one has to go through when reading two instances
		 * of the /etc/passwd file.  That's why there's some seeking,
		 * re-reading of the same record, and other junk.  Luckily, this
		 * feature won't be requested very often, and still isn't too
		 * slow...
		 */

		/* For each entry in the passwd database ... */
		while (plookpwd = local_getpwent()) {
			/*
			 * Optimization -- If the login's user-ID is already
			 * in the display list, there's no reason to process
			 * this  entry -- it's already there.
			 */
			if (!isuidindisp(plookpwd)) {
				/*
				 * Rememeber the current entry's position,
				 * so when we finish scanning through the
				 * database looking for duplicates we can
				 * return to the current place, so that the
				 * enclosing loop will march in an orderly
				 * fashion through the passwd database.
				 */
				done = FALSE;
				lookpos = local_pwtell();

				/*
				 * For each record in the passwd database
				 * beyond the searching record ...
				 */
				while (pwent = local_getpwent()) {

					/*
					 * If there's a match between the
					 * searcher's user-ID and the
					 * searchee's user-ID ...
					 */
					if (pwent->pw_uid == plookpwd->pw_uid) {
						/*
						 * If this is the first
						 * duplicate of this searcher
						 * that we find,
						 * add the searcher's
						 * record to the display list
						 * (It wants to be on the
						 * list first to avoid
						 * ordering "flakeyness")
						 */
						if (done == FALSE) {
							adddisp(plookpwd);
							done = TRUE;
						}

						/*
						 * Now add the searchee's
						 * record
						 */
						adddisp(pwent);

					}
				}
				/* Reposition to searcher record */
				local_pwseek(lookpos);
			}
		}

		local_endpwent();
	}


	/*
	 *  Loop through the passwd database squirelling away the
	 *  information we need for the display.
	 *
	 *  NOTE:  Once a login is added to the list, the rest of the
	 *	   body of the loop is bypassed (via a continue statement).
	 */

	doall = !(s_seen || u_seen || p_seen || d_seen || l_seen || g_seen);

	if (doall || s_seen || u_seen || p_seen || l_seen || g_seen) {

		while (pwent = local_getpwent()) {
			done = FALSE;

			/*
			 * If no user-specific options were specified,
			 * include this login-ID
			 */
			if (doall) {
				adddisp(pwent);
				continue;
			}

			/*
			 * If the user specified system login-IDs,
			 * and this is a system ID, include it
			 */
			if (s_seen) {
				if (isasystemlogin(pwent)) {
					adddisp(pwent);
					continue;
				}
			}

			/*
			 * If the user specified user login-IDs,
			 * and this is a user ID, include it
			 */
			if (u_seen) {
				if (isauserlogin(pwent)) {
					adddisp(pwent);
					continue;
				}
			}

			/*
			 * If the user is asking for login-IDs that have
			 * no password, and this one has no password, include it
			 */
			if (p_seen) {
				if (hasnopasswd(pwent)) {
					adddisp(pwent);
					continue;
				}
			}

			/*
			 * If specific logins were requested, leaf through
			 * the list of logins they requested.  If this login
			 * is on the list, include it.
			 */
			if (l_seen) {
				for (plogin = reqloginhead; !done && plogin;
				    plogin = plogin->next) {
					if (strcmp(pwent->pw_name,
					    plogin->loginname) == 0) {
						plogin->found = TRUE;
						adddisp(pwent);
						done = TRUE;
					}
				}
				if (done)
					continue;
			}

			/*
			 * If specific groups were requested, leaf through the
			 * list of login-IDs that belong to those groups.
			 * If this login-ID is in that list, or its primary
			 * group is one of those requested, include it.
			 */

			if (g_seen) {
				for (pgrp = reqgrphead; !done && pgrp;
				    pgrp = pgrp->next) {
					if (pwent->pw_gid == pgrp->groupID) {
						adddisp(pwent);
						done = TRUE;
					}
				}
				if (!done && isamember(pwent->pw_name)) {
					adddisp(pwent);
					done = TRUE;
				}
			}
			if (done)
				continue;
		}

		local_endpwent();
	}

	/* Let the user know about logins they requested that don't exist */
	if (l_seen) {
		for (plogin = reqloginhead; plogin; plogin = plogin->next) {
			if (!plogin->found) {
				wrtmsg(MM_WARNING, MM_NULLACT, MM_NULLTAG,
				    gettext("%s was not found"),
				    plogin->loginname);
			}
		}
	}

	/*  Apply group information */
	applygroup(m_seen);


	/*
	 * Apply password information (only needed if the extended
	 * set of information has been requested)
	 */
	if (x_seen || a_seen)
		applypasswd();


	/*
	 * Generate a report from this display items we've squirreled away
	 */

	if (t_seen)
		genlogreport(o_seen, x_seen, a_seen);
	else
		genuidreport(o_seen, x_seen, a_seen);

	/*  We're through! */
	return (0);
}