Big loginrec.c update

- MIN_SIZEOF macro to pick smallest buffer for str[ln]cpy()
  - fixes lastlog clobber spotted by P.S.S.Camp <P.S.S.Camp@ukc.ac.uk>
- Added some top-level api documentation
- Re-ordered construct_utmp(x)() to build well-formed structures for
   both login and logout, based on li->type.
  - change wtmp(x)_logout() to match new construct_*() form
- Improved error responses throughout
- Add ut_type cross-check for 'lastlog-from-wtmp(x)' where available
- utmp_write_direct() has had some testing. Oh yes!
- Re-ordered loginrec.h slightly

1 files changed, 250 insertions, 86 deletions

diff --git a/loginrec.c b/loginrec.c
index 59ce1808a..e51d686bf 100644
--- a/loginrec.c
+++ b/loginrec.c
@@ -141,10 +141,10 @@
  ** Known good:
  **   Linux (Redhat 6.2, need more variants)
  **   HP-UX 10.20 (gcc only)
+ **   IRIX
  **
  ** Testing required: Please send reports!
  **   Solaris
- **   IRIX
  **   NetBSD
  **   HP-UX 11
  **   AIX
@@ -170,7 +170,7 @@
 #include "xmalloc.h"
 #include "loginrec.h"
 
-RCSID("$Id: loginrec.c,v 1.6 2000/06/13 11:23:17 djm Exp $");
+RCSID("$Id: loginrec.c,v 1.7 2000/06/19 08:20:03 andre Exp $");
 
 /**
  ** prototypes for helper functions in this file
@@ -199,11 +199,28 @@ int wtmp_get_entry(struct logininfo *li);
 int wtmpx_get_entry(struct logininfo *li);
 
 
+#ifdef MIN
+# undef MIN
+# define MIN(a,b) ( (a)<(b) ? (a) : (b) )
+#endif
+
+/* pick the shortest string */
+#define MIN_SIZEOF(s1,s2) ( sizeof(s1) < sizeof(s2) ? sizeof(s1) : sizeof(s2) )
+
+
 /**
  ** platform-independent login functions
  **/
 
-/* Record a login */
+/* login_login(struct logininfo *)     -Record a login
+ * 
+ * Call with a pointer to a struct logininfo initialised with
+ * login_init_entry() or login_alloc_entry()
+ *
+ * Returns:
+ *  >0 if successful
+ *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
+ */
 int
 login_login (struct logininfo *li)
 {
@@ -212,7 +229,14 @@ login_login (struct logininfo *li)
 }
 
 
-/* Record a logout */
+/* login_logout(struct logininfo *)     - Record a logout
+ *
+ * Call as with login_login()
+ *
+ * Returns:
+ *  >0 if successful
+ *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
+ */
 int
 login_logout(struct logininfo *li)
 {
@@ -221,22 +245,65 @@ login_logout(struct logininfo *li)
 }
 
 
-/* Retrieve the last login time for a user (or fake on from wtmp/wtmpx) */
+/* login_get_lastlog_time(int)           - Retrieve the last login time
+ *
+ * Retrieve the last login time for the given uid. Will try to use the
+ * system lastlog facilities if they are available, but will fall back
+ * to looking in wtmp/wtmpx if necessary
+ *
+ * Returns:
+ *   0 on failure, or if user has never logged in
+ *   Time in seconds from the epoch if successful
+ *
+ * Useful preprocessor symbols:
+ *   DISABLE_LASTLOG: If set, *never* even try to retrieve lastlog
+ *                    info
+ *   USE_LASTLOG: If set, indicates the presence of system lastlog
+ *                facilities. If this and DISABLE_LASTLOG are not set,
+ *                try to retrieve lastlog information from wtmp/wtmpx.
+ */
 unsigned int
 login_get_lastlog_time(const int uid)
 {
         struct logininfo li;
 
-        login_get_lastlog(&li, uid);
-        return li.tv_sec;
+        if (login_get_lastlog(&li, uid))
+                return li.tv_sec;
+        else
+                return 0;
 }
 
-/* Retrieve a lastlog entry (or fake one from wtmp/wtmpx) */
+/* login_get_lastlog(struct logininfo *, int)   - Retrieve a lastlog entry
+ *
+ * Retrieve a logininfo structure populated (only partially) with
+ * information from the system lastlog data, or from wtmp/wtmpx if no
+ * system lastlog information exists.
+ *
+ * Note this routine must be given a pre-allocated logininfo.
+ *
+ * Returns:
+ *  >0: A pointer to your struct logininfo if successful
+ *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
+ *
+ */
 struct logininfo *
 login_get_lastlog(struct logininfo *li, const int uid)
 {
+#ifndef USE_LASTLOG
+        struct passwd *pw;
+#endif
+
         memset(li, '\0', sizeof(struct logininfo));
         li->uid = uid;
+
+#ifndef USE_LASTLOG
+        /* If we don't have a 'real' lastlog, we need the username to
+         * reliably search wtmp(x) for the last login (see
+         * wtmp_get_entry().) */
+        pw = getpwuid(uid);
+        strlcpy(li->username, pw->pw_name, 
+                MIN_SIZEOF(li->username, pw->pw_name));
+#endif
         if (getlast_entry(li))
                 return li;
         else
@@ -244,7 +311,15 @@ login_get_lastlog(struct logininfo *li, const int uid)
 }
 
 
-/* login_alloc_entry()    - allocate and initialise a logininfo */
+/* login_alloc_entry(int, char*, char*, char*)    - Allocate and initialise
+ *                                                  a logininfo structure 
+ * 
+ * This function creates a new struct logininfo, a data structure
+ * meant to carry the information required to portably record login info.
+ *
+ * Returns a pointer to a newly created struct logininfo. If memory
+ * allocation fails, the program halts.
+ */
 struct
 logininfo *login_alloc_entry(int pid, const char *username,
                              const char *hostname, const char *line)
@@ -257,7 +332,7 @@ logininfo *login_alloc_entry(int pid, const char *username,
 }
 
 
-/* login_free_entry()    - free struct memory (trivial) */
+/* login_free_entry(struct logininfo *)    - free struct memory */
 void
 login_free_entry(struct logininfo *li)
 {
@@ -265,7 +340,14 @@ login_free_entry(struct logininfo *li)
 }
 
 
-/* login_init_entry()   - initialise a struct logininfo */
+/* login_init_entry(struct logininfo *, int, char*, char*, char*)
+ *                                        - initialise a struct logininfo
+ * 
+ * Populates a new struct logininfo, a data structure meant to carry
+ * the information required to portably record login info.
+ *
+ * Returns: 1
+ */
 int
 login_init_entry(struct logininfo *li, int pid, const char *username, 
                  const char *hostname, const char *line)
@@ -285,7 +367,12 @@ login_init_entry(struct logininfo *li, int pid, const char *username,
         return 1;
 }
 
-
+/* login_set_current_time(struct logininfo *)    - set the current time
+ *
+ * Set the current time in a logininfo structure. This function is
+ * meant to eliminate the need to deal with system dependencies for
+ * time handling.
+ */
 void
 login_set_current_time(struct logininfo *li)
 {
@@ -502,12 +589,15 @@ construct_utmp(struct logininfo *li,
                     struct utmp *ut)
 {
         memset(ut, '\0', sizeof(struct utmp));
+
+        /* First fill out fields used for both logins and logouts */
+
 #ifdef HAVE_ID_IN_UTMP
         line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
 #endif
 
 #ifdef HAVE_TYPE_IN_UTMP
-        /* This is done here to keep utmp constants out of login.h */
+        /* This is done here to keep utmp constants out of struct logininfo */
         switch (li->type) {
         case LTYPE_LOGIN:
                 ut->ut_type = USER_PROCESS;
@@ -517,15 +607,24 @@ construct_utmp(struct logininfo *li,
                 break;
         }
 #endif
+        set_utmp_time(li, ut);
 
+        line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
 #ifdef HAVE_PID_IN_UTMP
         ut->ut_pid = li->pid;
 #endif
-        line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
-        strlcpy(ut->ut_name, li->username, sizeof(ut->ut_name));
-        set_utmp_time(li, ut);
+
+        /* If we're logging out, leave all other fields blank */
+        if (li->type == LTYPE_LOGOUT)
+          return;
+
+        /* These fields are only used when logging in, and are blank
+         *  for logouts. */
+
+        /* Use strncpy because we don't necessarily want null termination */
+        strncpy(ut->ut_user, li->username, MIN_SIZEOF(ut->ut_user, li->username));
 #ifdef HAVE_HOST_IN_UTMP
-        strlcpy(ut->ut_host, li->hostname, sizeof(ut->ut_host));
+        strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
 #endif
 #ifdef HAVE_ADDR_IN_UTMP
         /* this is just a 32-bit IP address */
@@ -578,19 +677,27 @@ construct_utmpx(struct logininfo *li, struct utmpx *utx)
                 utx->ut_type = DEAD_PROCESS;
                 break;
         }
-        utx->ut_pid = li->pid;
         line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
-        strlcpy(utx->ut_name, li->username, sizeof(utx->ut_name));
         set_utmpx_time(li, utx);
+        utx->ut_pid = li->pid;
+
+        if (li->type == LTYPE_LOGOUT)
+                return;
+
+        /* These fields are only used when logging in, and are blank
+         *  for logouts. */
+
+        /* strncpy(): Don't necessarily want null termination */
+        strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
 #ifdef HAVE_HOST_IN_UTMPX
-        strlcpy(utx->ut_host, li->hostname, sizeof(utx->ut_host));
+        strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
 #endif
 #ifdef HAVE_ADDR_IN_UTMPX
         /* FIXME: (ATL) not supported yet */
 #endif
-#ifdef HAVE_SYSLEN_IN_UTMPX  
-        /* this is safe because of the extra nulls in logininfo */
-        utx->ut_syslen = strlen(li->hostname);
+#ifdef HAVE_SYSLEN_IN_UTMPX
+        /* ut_syslen is the length of the utx_host string */
+        utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
 #endif
 }
 
@@ -639,6 +746,7 @@ utmp_write_direct(struct logininfo *li, struct utmp *ut)
         register int fd;
         int tty;
 
+        /* FIXME: (ATL) ttyslot() needs local implementation */
         tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
 
         if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
@@ -658,7 +766,7 @@ utmp_write_direct(struct logininfo *li, struct utmp *ut)
                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
                 if (write(fd, ut, sizeof(struct utmp))==-1)
                         log("utmp_write_direct: error writing %s: %s",
-                                     UTMP_FILE, strerror(errno));
+                            UTMP_FILE, strerror(errno));
       
                 (void)close(fd);
                 return 1;
@@ -676,7 +784,7 @@ utmp_perform_login(struct logininfo *li)
         construct_utmp(li, &ut);
 #ifdef UTMP_USE_LIBRARY
         if (!utmp_write_library(li, &ut)) {
-          log("utmp_perform_login: utmp_write_library() failed");
+                log("utmp_perform_login: utmp_write_library() failed");
                 return 0;
         }
 #else
@@ -694,23 +802,18 @@ utmp_perform_logout(struct logininfo *li)
 {
         struct utmp ut;
 
-        memset(&ut, '\0', sizeof(ut));
-        set_utmp_time(li, &ut);
-        line_stripname(ut.ut_line, li->line, sizeof(ut.ut_line));
-#ifdef HAVE_ID_IN_UTMP
-        line_abbrevname(ut.ut_id, li->line, sizeof(ut.ut_id));
-#endif
-#ifdef HAVE_TYPE_IN_UTMP
-        ut.ut_type = DEAD_PROCESS;
-#endif
-
-#if   !defined(DISABLE_PUTUTLINE) \
-    && defined(HAVE_SETUTENT) && defined(HAVE_PUTUTLINE)
-        utmp_write_library(li, &ut);
+        construct_utmp(li, &ut);
+#ifdef UTMP_USE_LIBRARY
+        if (!utmp_write_library(li, &ut)) {
+                log("utmp_perform_logout: utmp_write_library() failed");
+                return 0;
+        }
 #else
-        utmp_write_direct(li, &ut);
+        if (!utmp_write_direct(li, &ut)) {
+                log("utmp_perform_logout: utmp_write_direct() failed");
+                return 0;
+        }
 #endif
-
         return 1;
 }
 
@@ -890,17 +993,6 @@ wtmp_perform_logout(struct logininfo *li)
         struct utmp ut;
 
         construct_utmp(li, &ut);
-        /* blank out unnecessary fields */
-        memset(&(ut.ut_name), '\0', sizeof(ut.ut_name));
-#ifdef HAVE_ID_IN_UTMP
-        memset(&(ut.ut_id), '\0', sizeof(ut.ut_id));
-#endif
-#ifdef HAVE_HOST_IN_UTMP
-        memset(&(ut.ut_host), '\0', sizeof(ut.ut_host));
-#endif
-#ifdef HAVE_ADDR_IN_UTMP
-        memset(&(ut.ut_addr), '\0', sizeof(ut.ut_addr));
-#endif
         return wtmp_write(li, &ut);
 }
 
@@ -920,12 +1012,49 @@ wtmp_write_entry(struct logininfo *li)
 }
 
 
+/* Notes on fetching login data from wtmp/wtmpx
+ * 
+ * Logouts are usually recorded with (amongst other things) a blank
+ * username on a given tty line.  However, some systems (HP-UX is one)
+ * leave all fields set, but change the ut_type field to DEAD_PROCESS.
+ *
+ * Since we're only looking for logins here, we know that the username
+ * must be set correctly. On systems that leave it in, we check for
+ * ut_type==USER_PROCESS (indicating a login.)
+ *
+ * Portability: Some systems may set something other than USER_PROCESS
+ * to indicate a login process. I don't know of any as I write. Also,
+ * it's possible that some systems may both leave the username in
+ * place and not have ut_type.
+ */
+
+
+/* return true if this wtmp entry indicates a login */
+static int
+wtmp_islogin(struct logininfo *li, struct utmp *ut)
+{
+        if ( strncmp(li->username, ut->ut_user,
+                     MIN_SIZEOF(li->username, ut->ut_user)) == 0 ) {
+#ifdef HAVE_TYPE_IN_UTMP
+                if (ut->ut_type & USER_PROCESS)
+                        return 1;
+#else
+                return 1;
+#endif
+        }
+        return 0;
+}
+
+
 int
 wtmp_get_entry(struct logininfo *li)
 {
         struct stat st;
         struct utmp ut;
-        int fd;
+        int fd, found=0;
+
+        /* Clear the time entries in our logininfo */
+        li->tv_sec = li->tv_usec = 0;
 
         if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
                 log("wtmp_get_entry: problem opening %s: %s",
@@ -938,19 +1067,25 @@ wtmp_get_entry(struct logininfo *li)
                 close(fd);
                 return 0;
         }
-        (void)lseek(fd, (off_t)(0-sizeof(struct utmp)), SEEK_END);
 
-        do {
+        /* Seek to the start of the last struct utmp */
+        if (lseek(fd, (off_t)(0-sizeof(struct utmp)), SEEK_END) == -1) {
+                /* Looks like we've got a fresh wtmp file */
+                close(fd);
+                return 0;
+        }
+
+        while (!found) {
                 if (read(fd, &ut, sizeof(ut)) != sizeof(ut)) {
                         log("wtmp_get_entry: read of %s failed: %s",
                             WTMP_FILE, strerror(errno));
                         close (fd);
                         return 0;
                 }
-                /* Logouts are recorded as a blank username on a particular line.
-                 * So, we just need to find the username in struct utmp */
-                if ( strncmp(li->username, ut.ut_user, 8) == 0 ) {
-                        /* note we've already made sure there's a time in struct utmp */
+                if ( wtmp_islogin(li, &ut) ) {
+                        found = 1;
+                        /* We've already checked for a time in struct
+                         * utmp, in login_getlast(). */
 #ifdef HAVE_TIME_IN_UTMP
                         li->tv_sec = ut.ut_time;
 #else
@@ -958,17 +1093,24 @@ wtmp_get_entry(struct logininfo *li)
                         li->tv_sec = ut.ut_tv.tv_sec;
 #  endif
 #endif
-                        line_fullname(li->line, ut.ut_line, sizeof(li->line));
+                        line_fullname(li->line, ut.ut_line,
+                                      MIN_SIZEOF(li->line, ut.ut_line));
 #ifdef HAVE_HOST_IN_UTMP
-                        strlcpy(li->hostname, ut.ut_host, sizeof(li->hostname));
+                        strlcpy(li->hostname, ut.ut_host,
+                                MIN_SIZEOF(li->hostname, ut.ut_host));
 #endif
+                        continue;
                 }
+                /* Seek back 2 x struct utmp */
                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmp)), SEEK_CUR) == -1) {
+                        /* We've found the start of the file, so quit */
                         close (fd);
                         return 0;
                 }
-        } while (li->tv_sec == 0);
-      
+        }
+
+        /* We found an entry. Tidy up and return */
+        close(fd);
         return 1;
 }
 
@@ -1027,19 +1169,7 @@ wtmpx_perform_logout(struct logininfo *li)
         struct utmpx utx;
 
         construct_utmpx(li, &utx);
-        /* blank out unnecessary fields */
-        memset(&(utx.ut_name), '\0', sizeof(utx.ut_name));
-#ifdef HAVE_ID_IN_UTMPX
-        memset(&(utx.ut_id), '\0', sizeof(utx.ut_id));
-#endif
-#ifdef HAVE_HOST_IN_UTMPX
-        memset(&(utx.ut_host), '\0', sizeof(utx.ut_host));
-#endif
-#ifdef HAVE_ADDR_IN_UTMPX
-        memset(&(utx.ut_addr), '\0', sizeof(utx.ut_addr));
-#endif
         return wtmpx_write(li, &utx);
-
 }
 
 
@@ -1057,13 +1187,35 @@ wtmpx_write_entry(struct logininfo *li)
         }
 }
 
+/* Please see the notes above wtmp_islogin() for information about the
+   next two functions */
+
+/* Return true if this wtmpx entry indicates a login */
+static int
+wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
+{
+        if ( strncmp(li->username, utx->ut_user,
+                     MIN_SIZEOF(li->username, utx->us_user)) == 0 ) {
+#ifdef HAVE_TYPE_IN_UTMPX
+                if (utx->ut_type == USER_PROCESS)
+                        return 1;
+#else
+                return 1;
+#endif
+        }
+        return 0;
+}
+
 
 int
 wtmpx_get_entry(struct logininfo *li)
 {
         struct stat st;
         struct utmpx utx;
-        int fd;
+        int fd, found=0;
+
+        /* Clear the time entries */
+        li->tv_sec = li->tv_usec = 0;
 
         if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
                 log("wtmpx_get_entry: problem opening %s: %s",
@@ -1076,9 +1228,15 @@ wtmpx_get_entry(struct logininfo *li)
                 close(fd);
                 return 0;
         }
-        (void)lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END);
+        
+        /* Seek to the start of the last struct utmpx */
+        if (lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END) == -1 ) {
+                /* probably a newly rotated wtmpx file */
+                close(fd);
+                return 0;
+        }
 
-        do {
+        while (!found) {
                 if (read(fd, &utx, sizeof(utx)) != sizeof(utx)) {
                         log("wtmpx_get_entry: read of %s failed: %s",
                             WTMPX_FILE, strerror(errno));
@@ -1087,8 +1245,7 @@ wtmpx_get_entry(struct logininfo *li)
                 }
                 /* Logouts are recorded as a blank username on a particular line.
                  * So, we just need to find the username in struct utmpx */
-                if ( strncmp(li->username, utx.ut_user, 8) == 0 ) {
-                        /* note we've already made sure there's a time in struct utmp */
+                if ( wtmpx_islogin(li, &utx) ) {
 #ifdef HAVE_TV_IN_UTMPX
                         li->tv_sec = utx.ut_tv.tv_sec;
 #else
@@ -1098,14 +1255,18 @@ wtmpx_get_entry(struct logininfo *li)
 #endif
                         line_fullname(li->line, utx.ut_line, sizeof(li->line));
 #ifdef HAVE_HOST_IN_UTMPX
-                        strlcpy(li->hostname, utx.ut_host, sizeof(li->hostname));
+                        strlcpy(li->hostname, utx.ut_host,
+                                MIN_SIZEOF(li->hostname, utx.ut_host));
 #endif
+                        continue;
                 }
                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmpx)), SEEK_CUR) == -1) {
                         close (fd);
                         return 0;
                 }
-        } while (li->tv_sec == 0);
+        }
+
+        close(fd);
         return 1;
 }
 
@@ -1150,9 +1311,10 @@ syslogin_perform_logout(struct logininfo *li)
                 logwtmp(line, "", "");
         }
 # endif
-        /* TODO: what to do if we have login, but no logout?
-         * what if logout but no logwtmp? All routines are in libutil
-         * so they should all be there, but... */
+        /* FIXME: (ATL - if the need arises) What to do if we have
+         * login, but no logout?  what if logout but no logwtmp? All
+         * routines are in libutil so they should all be there,
+         * but... */
 #endif
         return 1;
 }
@@ -1192,7 +1354,8 @@ lastlog_construct(struct logininfo *li, struct lastlog *last)
   
         (void)line_stripname(last->ll_line, li->line,
                              sizeof(last->ll_line));
-        strlcpy(last->ll_host, li->hostname, sizeof(last->ll_host));
+        strlcpy(last->ll_host, li->hostname,
+                MIN_SIZEOF(last->ll_host, li->hostname));
         last->ll_time = li->tv_sec;
 }
 
@@ -1300,7 +1463,8 @@ static void
 lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
 {
         line_fullname(li->line, last->ll_line, sizeof(li->line));
-        strlcpy(li->hostname, last->ll_host, sizeof(li->hostname));
+        strlcpy(li->hostname, last->ll_host,
+                MIN_SIZEOF(li->hostname, last->ll_host));
         li->tv_sec = last->ll_time;
 }