539 lines
12 KiB
C
539 lines
12 KiB
C
/* $NetBSD: lastlogin.c,v 1.20 2020/05/07 12:52:40 wiz Exp $ */
|
|
/*
|
|
* Copyright (c) 1996 John M. Vinopal
|
|
* 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. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed for the NetBSD Project
|
|
* by John M. Vinopal.
|
|
* 4. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <sys/cdefs.h>
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: lastlogin.c,v 1.20 2020/05/07 12:52:40 wiz Exp $");
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <err.h>
|
|
#include <db.h>
|
|
#include <errno.h>
|
|
#include <pwd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <time.h>
|
|
#include <arpa/inet.h>
|
|
#include <sys/socket.h>
|
|
#ifdef SUPPORT_UTMP
|
|
#include <utmp.h>
|
|
#endif
|
|
#ifdef SUPPORT_UTMPX
|
|
#include <utmpx.h>
|
|
#endif
|
|
#include <unistd.h>
|
|
#include <util.h>
|
|
|
|
#ifndef UT_NAMESIZE
|
|
# define UT_NAMESIZE 8
|
|
#endif
|
|
#ifndef UT_LINESIZE
|
|
# define UT_LINESIZE 8
|
|
#endif
|
|
#ifndef UT_HOSTSIZE
|
|
# define UT_HOSTSIZE 16
|
|
#endif
|
|
|
|
#ifndef UTX_USERSIZE
|
|
# define UTX_USERSIZE 64
|
|
#endif
|
|
#ifndef UTX_LINESIZE
|
|
# define UTX_LINESIZE 64
|
|
#endif
|
|
#ifndef UTX_HOSTSIZE
|
|
# define UTX_HOSTSIZE 256
|
|
#endif
|
|
|
|
/*
|
|
* Fields in the structure below are 1 byte longer than the maximum possible
|
|
* for NUL-termination.
|
|
*/
|
|
struct output {
|
|
struct timeval o_tv;
|
|
char o_name[UTX_USERSIZE+1];
|
|
char o_line[UTX_LINESIZE+1];
|
|
char o_host[UTX_HOSTSIZE+1];
|
|
struct output *next;
|
|
};
|
|
|
|
#define SORT_NONE 0x0000
|
|
#define SORT_REVERSE 0x0001
|
|
#define SORT_TIME 0x0002
|
|
#define DOSORT(x) ((x) & (SORT_TIME))
|
|
static int sortlog = SORT_NONE;
|
|
static struct output *outstack = NULL;
|
|
static struct output *outstack_p = NULL;
|
|
|
|
static int fixed = 0;
|
|
#define FIXED_NAMELEN UT_NAMESIZE
|
|
#define FIXED_LINELEN UT_LINESIZE
|
|
/*
|
|
* This makes the "fixed" output fit in 79 columns.
|
|
* Using UT_HOSTSIZE (16) seems too conservative.
|
|
*/
|
|
#define FIXED_HOSTLEN 32
|
|
|
|
static int numeric = 0;
|
|
static size_t namelen = 0;
|
|
static size_t linelen = 0;
|
|
static size_t hostlen = 0;
|
|
#define SIZECOLUMNS (!(namelen && linelen && hostlen))
|
|
|
|
static int comparelog(const void *, const void *);
|
|
static void output_record(struct output *);
|
|
#ifdef SUPPORT_UTMP
|
|
static void process_entry(struct passwd *, struct lastlog *);
|
|
static void dolastlog(const char *, int, char *[]);
|
|
#endif
|
|
#ifdef SUPPORT_UTMPX
|
|
static void process_entryx(struct passwd *, struct lastlogx *);
|
|
static void dolastlogx(const char *, int, char *[]);
|
|
#endif
|
|
static void append_record(struct output *);
|
|
static void sizecolumns(struct output *);
|
|
static void output_stack(struct output *);
|
|
static void sort_and_output_stack(struct output *);
|
|
__dead static void usage(void);
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
const char *logfile =
|
|
#if defined(SUPPORT_UTMPX)
|
|
_PATH_LASTLOGX;
|
|
#elif defined(SUPPORT_UTMP)
|
|
_PATH_LASTLOG;
|
|
#else
|
|
#error "either SUPPORT_UTMP or SUPPORT_UTMPX must be defined"
|
|
#endif
|
|
int ch;
|
|
size_t len;
|
|
|
|
while ((ch = getopt(argc, argv, "f:FH:L:nN:rt")) != -1) {
|
|
switch (ch) {
|
|
case 'H':
|
|
hostlen = atoi(optarg);
|
|
break;
|
|
case 'f':
|
|
logfile = optarg;
|
|
break;
|
|
case 'F':
|
|
fixed++;
|
|
break;
|
|
case 'L':
|
|
linelen = atoi(optarg);
|
|
break;
|
|
case 'n':
|
|
numeric++;
|
|
break;
|
|
case 'N':
|
|
namelen = atoi(optarg);
|
|
break;
|
|
case 'r':
|
|
sortlog |= SORT_REVERSE;
|
|
break;
|
|
case 't':
|
|
sortlog |= SORT_TIME;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (fixed) {
|
|
if (!namelen)
|
|
namelen = FIXED_NAMELEN;
|
|
if (!linelen)
|
|
linelen = FIXED_LINELEN;
|
|
if (!hostlen)
|
|
hostlen = FIXED_HOSTLEN;
|
|
}
|
|
|
|
len = strlen(logfile);
|
|
|
|
setpassent(1); /* Keep passwd file pointers open */
|
|
|
|
#if defined(SUPPORT_UTMPX)
|
|
if (len > 0 && logfile[len - 1] == 'x')
|
|
dolastlogx(logfile, argc, argv);
|
|
else
|
|
#endif
|
|
#if defined(SUPPORT_UTMP)
|
|
dolastlog(logfile, argc, argv);
|
|
#endif
|
|
|
|
setpassent(0); /* Close passwd file pointers */
|
|
|
|
if (outstack) {
|
|
if (SIZECOLUMNS)
|
|
sizecolumns(outstack);
|
|
|
|
if (DOSORT(sortlog))
|
|
sort_and_output_stack(outstack);
|
|
else
|
|
output_stack(outstack);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef SUPPORT_UTMP
|
|
static void
|
|
dolastlog(const char *logfile, int argc, char **argv)
|
|
{
|
|
int i;
|
|
FILE *fp = fopen(logfile, "r");
|
|
struct passwd *passwd;
|
|
struct lastlog l;
|
|
|
|
if (fp == NULL)
|
|
err(1, "%s", logfile);
|
|
|
|
/* Process usernames given on the command line. */
|
|
if (argc > 0) {
|
|
off_t offset;
|
|
for (i = 0; i < argc; i++) {
|
|
if ((passwd = getpwnam(argv[i])) == NULL) {
|
|
warnx("user '%s' not found", argv[i]);
|
|
continue;
|
|
}
|
|
/* Calculate the offset into the lastlog file. */
|
|
offset = passwd->pw_uid * sizeof(l);
|
|
if (fseeko(fp, offset, SEEK_SET)) {
|
|
warn("fseek error");
|
|
continue;
|
|
}
|
|
if (fread(&l, sizeof(l), 1, fp) != 1) {
|
|
warnx("fread error on '%s'", passwd->pw_name);
|
|
clearerr(fp);
|
|
continue;
|
|
}
|
|
process_entry(passwd, &l);
|
|
}
|
|
}
|
|
/* Read all lastlog entries, looking for active ones */
|
|
else {
|
|
for (i = 0; fread(&l, sizeof(l), 1, fp) == 1; i++) {
|
|
if (l.ll_time == 0)
|
|
continue;
|
|
if ((passwd = getpwuid(i)) == NULL) {
|
|
static struct passwd p;
|
|
static char n[32];
|
|
snprintf(n, sizeof(n), "(%d)", i);
|
|
p.pw_uid = i;
|
|
p.pw_name = n;
|
|
passwd = &p;
|
|
}
|
|
process_entry(passwd, &l);
|
|
}
|
|
if (ferror(fp))
|
|
warnx("fread error");
|
|
}
|
|
|
|
(void)fclose(fp);
|
|
}
|
|
|
|
static void
|
|
process_entry(struct passwd *p, struct lastlog *l)
|
|
{
|
|
struct output o;
|
|
|
|
memset(&o, 0, sizeof(o));
|
|
if (numeric > 1)
|
|
(void)snprintf(o.o_name, sizeof(o.o_name), "%d", p->pw_uid);
|
|
else
|
|
(void)strlcpy(o.o_name, p->pw_name, sizeof(o.o_name));
|
|
(void)memcpy(o.o_line, l->ll_line, sizeof(l->ll_line));
|
|
(void)memcpy(o.o_host, l->ll_host, sizeof(l->ll_host));
|
|
o.o_tv.tv_sec = l->ll_time;
|
|
o.o_tv.tv_usec = 0;
|
|
o.next = NULL;
|
|
|
|
/*
|
|
* If we are dynamically sizing the columns or sorting the log,
|
|
* we need all the entries in memory so push the current entry
|
|
* onto a stack. Otherwise, we can just output it.
|
|
*/
|
|
if (SIZECOLUMNS || DOSORT(sortlog))
|
|
append_record(&o);
|
|
else
|
|
output_record(&o);
|
|
}
|
|
#endif
|
|
|
|
#ifdef SUPPORT_UTMPX
|
|
static void
|
|
dolastlogx(const char *logfile, int argc, char **argv)
|
|
{
|
|
int i = 0;
|
|
DB *db = dbopen(logfile, O_RDONLY|O_SHLOCK, 0, DB_HASH, NULL);
|
|
DBT key, data;
|
|
struct lastlogx l;
|
|
struct passwd *passwd;
|
|
|
|
if (db == NULL)
|
|
err(1, "%s", logfile);
|
|
|
|
if (argc > 0) {
|
|
for (i = 0; i < argc; i++) {
|
|
if ((passwd = getpwnam(argv[i])) == NULL) {
|
|
warnx("User `%s' not found", argv[i]);
|
|
continue;
|
|
}
|
|
key.data = &passwd->pw_uid;
|
|
key.size = sizeof(passwd->pw_uid);
|
|
|
|
switch ((*db->get)(db, &key, &data, 0)) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
warnx("User `%s' not found", passwd->pw_name);
|
|
continue;
|
|
case -1:
|
|
warn("Error looking up `%s'", passwd->pw_name);
|
|
continue;
|
|
default:
|
|
abort();
|
|
}
|
|
|
|
if (data.size != sizeof(l)) {
|
|
errno = EFTYPE;
|
|
err(1, "%s", logfile);
|
|
}
|
|
(void)memcpy(&l, data.data, sizeof(l));
|
|
|
|
process_entryx(passwd, &l);
|
|
}
|
|
}
|
|
/* Read all lastlog entries, looking for active ones */
|
|
else {
|
|
switch ((*db->seq)(db, &key, &data, R_FIRST)) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
warnx("No entries found");
|
|
(*db->close)(db);
|
|
return;
|
|
case -1:
|
|
warn("Error seeking to first entry");
|
|
(*db->close)(db);
|
|
return;
|
|
default:
|
|
abort();
|
|
}
|
|
|
|
do {
|
|
uid_t uid;
|
|
|
|
if (key.size != sizeof(uid) || data.size != sizeof(l)) {
|
|
errno = EFTYPE;
|
|
err(1, "%s", logfile);
|
|
}
|
|
(void)memcpy(&uid, key.data, sizeof(uid));
|
|
|
|
if ((passwd = getpwuid(uid)) == NULL) {
|
|
static struct passwd p;
|
|
static char n[32];
|
|
snprintf(n, sizeof(n), "(%d)", i);
|
|
p.pw_uid = i;
|
|
p.pw_name = n;
|
|
passwd = &p;
|
|
}
|
|
(void)memcpy(&l, data.data, sizeof(l));
|
|
process_entryx(passwd, &l);
|
|
} while ((i = (*db->seq)(db, &key, &data, R_NEXT)) == 0);
|
|
|
|
switch (i) {
|
|
case 1:
|
|
break;
|
|
case -1:
|
|
warn("Error seeking to last entry");
|
|
break;
|
|
case 0:
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
|
|
(*db->close)(db);
|
|
}
|
|
|
|
static void
|
|
process_entryx(struct passwd *p, struct lastlogx *l)
|
|
{
|
|
struct output o;
|
|
|
|
memset(&o, 0, sizeof(o));
|
|
if (numeric > 1)
|
|
(void)snprintf(o.o_name, sizeof(o.o_name), "%d", p->pw_uid);
|
|
else
|
|
(void)strlcpy(o.o_name, p->pw_name, sizeof(o.o_name));
|
|
(void)memcpy(o.o_line, l->ll_line, sizeof(l->ll_line));
|
|
if (numeric)
|
|
(void)sockaddr_snprintf(o.o_host, sizeof(o.o_host), "%a",
|
|
(struct sockaddr *)&l->ll_ss);
|
|
else
|
|
(void)memcpy(o.o_host, l->ll_host, sizeof(l->ll_host));
|
|
o.o_tv = l->ll_tv;
|
|
o.next = NULL;
|
|
|
|
/*
|
|
* If we are dynamically sizing the columns or sorting the log,
|
|
* we need all the entries in memory so push the current entry
|
|
* onto a stack. Otherwise, we can just output it.
|
|
*/
|
|
if (SIZECOLUMNS || DOSORT(sortlog))
|
|
append_record(&o);
|
|
else
|
|
output_record(&o);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
append_record(struct output *o)
|
|
{
|
|
struct output *out;
|
|
|
|
out = malloc(sizeof(*out));
|
|
if (!out)
|
|
err(EXIT_FAILURE, "malloc failed");
|
|
(void)memcpy(out, o, sizeof(*out));
|
|
out->next = NULL;
|
|
|
|
if (outstack_p)
|
|
outstack_p = outstack_p->next = out;
|
|
else
|
|
outstack = outstack_p = out;
|
|
}
|
|
|
|
static void
|
|
sizecolumns(struct output *stack)
|
|
{
|
|
struct output *o;
|
|
size_t len;
|
|
|
|
if (!namelen)
|
|
for (o = stack; o; o = o->next) {
|
|
len = strlen(o->o_name);
|
|
if (namelen < len)
|
|
namelen = len;
|
|
}
|
|
|
|
if (!linelen)
|
|
for (o = stack; o; o = o->next) {
|
|
len = strlen(o->o_line);
|
|
if (linelen < len)
|
|
linelen = len;
|
|
}
|
|
|
|
if (!hostlen)
|
|
for (o = stack; o; o = o->next) {
|
|
len = strlen(o->o_host);
|
|
if (hostlen < len)
|
|
hostlen = len;
|
|
}
|
|
}
|
|
|
|
static void
|
|
output_stack(struct output *stack)
|
|
{
|
|
struct output *o;
|
|
|
|
for (o = stack; o; o = o->next)
|
|
output_record(o);
|
|
}
|
|
|
|
static void
|
|
sort_and_output_stack(struct output *o)
|
|
{
|
|
struct output **outs;
|
|
struct output *tmpo;
|
|
int num;
|
|
int i;
|
|
|
|
/* count the number of entries to display */
|
|
for (num=0, tmpo = o; tmpo; tmpo = tmpo->next, num++)
|
|
;
|
|
|
|
outs = malloc(sizeof(*outs) * num);
|
|
if (!outs)
|
|
err(EXIT_FAILURE, "malloc failed");
|
|
for (i=0, tmpo = o; i < num; tmpo=tmpo->next, i++)
|
|
outs[i] = tmpo;
|
|
|
|
mergesort(outs, num, sizeof(*outs), comparelog);
|
|
|
|
for (i=0; i < num; i++)
|
|
output_record(outs[i]);
|
|
}
|
|
|
|
static int
|
|
comparelog(const void *left, const void *right)
|
|
{
|
|
const struct output *l = *(const struct output * const *)left;
|
|
const struct output *r = *(const struct output * const *)right;
|
|
int order = (sortlog&SORT_REVERSE)?-1:1;
|
|
|
|
if (l->o_tv.tv_sec < r->o_tv.tv_sec)
|
|
return 1 * order;
|
|
if (l->o_tv.tv_sec == r->o_tv.tv_sec)
|
|
return 0;
|
|
return -1 * order;
|
|
}
|
|
|
|
/* Duplicate the output of last(1) */
|
|
static void
|
|
output_record(struct output *o)
|
|
{
|
|
time_t t = (time_t)o->o_tv.tv_sec;
|
|
printf("%-*.*s %-*.*s %-*.*s %s",
|
|
(int)namelen, (int)namelen, o->o_name,
|
|
(int)linelen, (int)linelen, o->o_line,
|
|
(int)hostlen, (int)hostlen, o->o_host,
|
|
t ? ctime(&t) : "Never logged in\n");
|
|
}
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
(void)fprintf(stderr, "Usage: %s [-Fnrt] [-f filename] "
|
|
"[-H hostsize] [-L linesize] [-N namesize] [user ...]\n",
|
|
getprogname());
|
|
exit(1);
|
|
}
|