/* * Copyright 1989 - 1993, Julianne Frances Haugh * 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. Neither the name of Julianne F. Haugh nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY JULIE HAUGH 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 JULIE HAUGH 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 #include "rcsid.h" RCSID(PKG_VER "$Id: faillog.c,v 1.10 2000/08/26 18:27:18 marekm Exp $") #include #include #include #include #include #include "prototypes.h" #include "defines.h" #include "faillog.h" static char *Prog; /* program name */ static FILE *fail; /* failure file stream */ static uid_t user; /* one single user, specified on command line */ static int days; /* number of days to consider for print command */ static time_t seconds; /* that number of days in seconds */ static int aflg = 0, /* set if all users are to be printed always */ uflg = 0, /* set if user is a valid user id */ tflg = 0; /* print is restricted to most recent days */ static struct stat statbuf; /* fstat buffer for file size */ #if !defined(UNISTD_H) && !defined(STDLIB_H) extern char *optarg; #endif #define NOW (time((time_t *) 0)) /* local function prototypes */ static void usage(void); static void print(void); static void print_one(const struct faillog *, uid_t); static void reset(void); static int reset_one(uid_t); static void setmax(int); static void setmax_one(uid_t, int); static void set_locktime(long); static void set_locktime_one(uid_t, long); static void usage(void) { fprintf(stderr, _("usage: %s [-a|-u user] [-m max] [-r] [-t days] [-l locksecs]\n"), Prog); exit(1); } int main(int argc, char **argv) { int c, anyflag = 0; struct passwd *pwent; Prog = Basename(argv[0]); setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); /* try to open for read/write, if that fails - read only */ fail = fopen(FAILLOG_FILE, "r+"); if (!fail) fail = fopen(FAILLOG_FILE, "r"); if (!fail) { perror(FAILLOG_FILE); exit(1); } while ((c = getopt(argc, argv, "al:m:pru:t:")) != EOF) { switch (c) { case 'a': aflg++; if (uflg) usage(); break; case 'l': set_locktime((long) atoi(optarg)); anyflag++; break; case 'm': setmax(atoi(optarg)); anyflag++; break; case 'p': print(); anyflag++; break; case 'r': reset(); anyflag++; break; case 'u': if (aflg) usage(); pwent = getpwnam(optarg); if (!pwent) { fprintf(stderr, _("Unknown User: %s\n"), optarg); exit(1); } uflg++; user = pwent->pw_uid; break; case 't': days = atoi(optarg); seconds = days * DAY; tflg++; break; default: usage(); } } /* no flags implies -a -p (= print information for all users) */ if (!(anyflag || aflg || tflg || uflg)) aflg++; /* (-a or -t days or -u user) and no other flags implies -p (= print information for selected users) */ if (!anyflag && (aflg || tflg || uflg)) print(); fclose(fail); return 0; /*NOTREACHED*/ } static void print(void) { uid_t uid; off_t offset; struct faillog faillog; if (uflg) { offset = user * sizeof faillog; if (fstat(fileno(fail), &statbuf)) { perror(FAILLOG_FILE); return; } if (offset >= statbuf.st_size) return; fseek(fail, (off_t) user * sizeof faillog, SEEK_SET); if (fread((char *) &faillog, sizeof faillog, 1, fail) == 1) print_one(&faillog, user); else perror(FAILLOG_FILE); } else { for (uid = 0; fread((char *) &faillog, sizeof faillog, 1, fail) == 1; uid++) { if (aflg == 0 && faillog.fail_cnt == 0) continue; if (aflg == 0 && tflg && NOW - faillog.fail_time > seconds) continue; if (aflg && faillog.fail_time == 0) continue; print_one(&faillog, uid); } } } static void print_one(const struct faillog *fl, uid_t uid) { static int once; char *cp; struct tm *tm; time_t now; struct passwd *pwent; #ifdef HAVE_STRFTIME char ptime[80]; #endif if (!once) { printf(_("Username Failures Maximum Latest\n")); once++; } pwent = getpwuid(uid); time(&now); tm = localtime(&fl->fail_time); #ifdef HAVE_STRFTIME strftime(ptime, sizeof(ptime), "%a %b %e %H:%M:%S %z %Y",tm); cp = ptime; #else cp = asctime(tm); cp[24] = '\0'; #endif if (pwent) { printf("%-12s %4d %4d", pwent->pw_name, fl->fail_cnt, fl->fail_max); if (fl->fail_time) { printf(_(" %s on %s"), cp, fl->fail_line); if (fl->fail_locktime) { if (fl->fail_time + fl->fail_locktime > now && fl->fail_cnt) printf(_(" [%lds left]"), fl->fail_time + fl->fail_locktime - now); else printf(_(" [%lds lock]"), fl->fail_locktime); } } putchar('\n'); } } static void reset(void) { uid_t uid; if (uflg) reset_one(user); else for (uid = 0; reset_one(uid); uid++) ; } static int reset_one(uid_t uid) { off_t offset; struct faillog faillog; offset = uid * sizeof faillog; if (fstat(fileno(fail), &statbuf)) { perror(FAILLOG_FILE); return 0; } if (offset >= statbuf.st_size) return 0; if (fseek(fail, offset, SEEK_SET) != 0) { perror(FAILLOG_FILE); return 0; } if (fread((char *) &faillog, sizeof faillog, 1, fail) != 1) { if (!feof(fail)) perror(FAILLOG_FILE); return 0; } if (faillog.fail_cnt == 0) return 1; /* don't fill in no holes ... */ faillog.fail_cnt = 0; if (fseek(fail, offset, SEEK_SET) == 0 && fwrite((char *) &faillog, sizeof faillog, 1, fail) == 1) { fflush(fail); return 1; } else { perror(FAILLOG_FILE); } return 0; } static void setmax(int max) { struct passwd *pwent; if (uflg) { setmax_one(user, max); } else { setpwent(); while ((pwent = getpwent())) setmax_one(pwent->pw_uid, max); } } static void setmax_one(uid_t uid, int max) { off_t offset; struct faillog faillog; offset = uid * sizeof faillog; if (fseek(fail, offset, SEEK_SET) != 0) { perror(FAILLOG_FILE); return; } if (fread((char *) &faillog, sizeof faillog, 1, fail) != 1) { if (!feof(fail)) perror(FAILLOG_FILE); memzero(&faillog, sizeof faillog); } faillog.fail_max = max; if (fseek(fail, offset, SEEK_SET) == 0 && fwrite((char *) &faillog, sizeof faillog, 1, fail) == 1) fflush(fail); else perror(FAILLOG_FILE); } /* * XXX - this needs to be written properly some day, right now it is * a quick cut-and-paste hack from the above two functions. --marekm */ static void set_locktime(long locktime) { struct passwd *pwent; if (uflg) { set_locktime_one(user, locktime); } else { setpwent(); while ((pwent = getpwent())) set_locktime_one(pwent->pw_uid, locktime); } } static void set_locktime_one(uid_t uid, long locktime) { off_t offset; struct faillog faillog; offset = uid * sizeof faillog; if (fseek(fail, offset, SEEK_SET) != 0) { perror(FAILLOG_FILE); return; } if (fread((char *) &faillog, sizeof faillog, 1, fail) != 1) { if (!feof(fail)) perror(FAILLOG_FILE); memzero(&faillog, sizeof faillog); } faillog.fail_locktime = locktime; if (fseek(fail, offset, SEEK_SET) == 0 && fwrite((char *) &faillog, sizeof faillog, 1, fail) == 1) fflush(fail); else perror(FAILLOG_FILE); }