loginrec.c

   1 /*
   2  * Copyright (c) 2000 Andre Lucas.  All rights reserved.
   3  * Portions copyright (c) 1998 Todd C. Miller
   4  * Portions copyright (c) 1996 Jason Downs
   5  * Portions copyright (c) 1996 Theo de Raadt
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by Markus Friedl.
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /**
  34  ** loginrec.c:  platform-independent login recording and lastlog retrieval
  35  **/
  36
  37 /*
  38   The new login code explained
  39   ============================
  40
  41   This code attempts to provide a common interface to login recording
  42   (utmp and friends) and last login time retrieval.
  43
  44   Its primary means of achieving this is to use 'struct logininfo', a
  45   union of all the useful fields in the various different types of
  46   system login record structures one finds on UNIX variants.
  47
  48   We depend on autoconf to define which recording methods are to be
  49   used, and which fields are contained in the relevant data structures
  50   on the local system. Many C preprocessor symbols affect which code
  51   gets compiled here.
  52
  53   The code is designed to make it easy to modify a particular
  54   recording method, without affecting other methods nor requiring so
  55   many nested conditional compilation blocks as were commonplace in
  56   the old code.
  57
  58   For login recording, we try to use the local system's libraries as
  59   these are clearly most likely to work correctly. For utmp systems
  60   this usually means login() and logout() or setutent() etc., probably
  61   in libutil, along with logwtmp() etc. On these systems, we fall back
  62   to writing the files directly if we have to, though this method
  63   requires very thorough testing so we do not corrupt local auditing
  64   information. These files and their access methods are very system
  65   specific indeed.
  66
  67   For utmpx systems, the corresponding library functions are
  68   setutxent() etc. To the author's knowledge, all utmpx systems have
  69   these library functions and so no direct write is attempted. If such
  70   a system exists and needs support, direct analogues of the [uw]tmp
  71   code should suffice.
  72
  73   Retrieving the time of last login ('lastlog') is in some ways even
  74   more problemmatic than login recording. Some systems provide a
  75   simple table of all users which we seek based on uid and retrieve a
  76   relatively standard structure. Others record the same information in
  77   a directory with a separate file, and others don't record the
  78   information separately at all. For systems in the latter category,
  79   we look backwards in the wtmp or wtmpx file for the last login entry
  80   for our user. Naturally this is slower and on busy systems could
  81   incur a significant performance penalty.
  82
  83   Calling the new code
  84   --------------------
  85
  86   In OpenSSH all login recording and retrieval is performed in
  87   login.c. Here you'll find working examples. Also, in the logintest.c
  88   program there are more examples.
  89
  90   Internal handler calling method
  91   -------------------------------
  92
  93   When a call is made to login_login() or login_logout(), both
  94   routines set a struct logininfo flag defining which action (log in,
  95   or log out) is to be taken. They both then call login_write(), which
  96   calls whichever of the many structure-specific handlers autoconf
  97   selects for the local system.
  98
  99   The handlers themselves handle system data structure specifics. Both
 100   struct utmp and struct utmpx have utility functions (see
 101   construct_utmp*()) to try to make it simpler to add extra systems
 102   that introduce new features to either structure.
 103
 104   While it may seem terribly wasteful to replicate so much similar
 105   code for each method, experience has shown that maintaining code to
 106   write both struct utmp and utmpx in one function, whilst maintaining
 107   support for all systems whether they have library support or not, is
 108   a difficult and time-consuming task.
 109
 110   Lastlog support proceeds similarly. Functions login_get_lastlog()
 111   (and its OpenSSH-tuned friend login_get_lastlog_time()) call
 112   getlast_entry(), which tries one of three methods to find the last
 113   login time. It uses local system lastlog support if it can,
 114   otherwise it tries wtmp or wtmpx before giving up and returning 0,
 115   meaning "tilt".
 116
 117   Maintenance
 118   -----------
 119
 120   In many cases it's possible to tweak autoconf to select the correct
 121   methods for a particular platform, either by improving the detection
 122   code (best), or by presetting DISABLE_<method> or CONF_<method>_FILE
 123   symbols for the platform.
 124
 125   Use logintest to check which symbols are defined before modifying
 126   configure.in and loginrec.c. (You have to build logintest yourself
 127   with 'make logintest' as it's not built by default.)
 128
 129   Otherwise, patches to the specific method(s) are very helpful!
 130
 131 */
 132
 133 /**
 134  ** TODO:
 135  **   homegrown ttyslot()
 136  **   test, test, test
 137  **
 138  ** Platform status:
 139  ** ----------------
 140  **
 141  ** Known good:
 142  **   Linux (Redhat 6.2, Debian)
 143  **   Solaris
 144  **   HP-UX 10.20 (gcc only)
 145  **   IRIX
 146  **   NeXT - M68k/HPPA/Sparc (4.2/3.3)
 147  **
 148  ** Testing required: Please send reports!
 149  **   NetBSD
 150  **   HP-UX 11
 151  **   AIX
 152  **
 153  ** Platforms with known problems:
 154  **   Some variants of Slackware Linux
 155  **
 156  **/
 157
 158 #include "includes.h"
 159
 160 #include "ssh.h"
 161 #include "xmalloc.h"
 162 #include "loginrec.h"
 163 #include "log.h"
 164 #include "atomicio.h"
 165
 166 RCSID("$Id$");
 167
 168 #ifdef HAVE_UTIL_H
 169 #  include <util.h>
 170 #endif
 171
 172 #ifdef HAVE_LIBUTIL_H
 173 #   include <libutil.h>
 174 #endif
 175
 176 /**
 177  ** prototypes for helper functions in this file
 178  **/
 179
 180 #if HAVE_UTMP_H
 181 void set_utmp_time(struct logininfo *li, struct utmp *ut);
 182 void construct_utmp(struct logininfo *li, struct utmp *ut);
 183 #endif
 184
 185 #ifdef HAVE_UTMPX_H
 186 void set_utmpx_time(struct logininfo *li, struct utmpx *ut);
 187 void construct_utmpx(struct logininfo *li, struct utmpx *ut);
 188 #endif
 189
 190 int utmp_write_entry(struct logininfo *li);
 191 int utmpx_write_entry(struct logininfo *li);
 192 int wtmp_write_entry(struct logininfo *li);
 193 int wtmpx_write_entry(struct logininfo *li);
 194 int lastlog_write_entry(struct logininfo *li);
 195 int syslogin_write_entry(struct logininfo *li);
 196
 197 int getlast_entry(struct logininfo *li);
 198 int lastlog_get_entry(struct logininfo *li);
 199 int wtmp_get_entry(struct logininfo *li);
 200 int wtmpx_get_entry(struct logininfo *li);
 201
 202 /* pick the shortest string */
 203 #define MIN_SIZEOF(s1,s2) ( sizeof(s1) < sizeof(s2) ? sizeof(s1) : sizeof(s2) )
 204
 205 /**
 206  ** platform-independent login functions
 207  **/
 208
 209 /* login_login(struct logininfo *)     -Record a login
 210  *
 211  * Call with a pointer to a struct logininfo initialised with
 212  * login_init_entry() or login_alloc_entry()
 213  *
 214  * Returns:
 215  *  >0 if successful
 216  *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
 217  */
 218 int
 219 login_login (struct logininfo *li)
 220 {
 221         li->type = LTYPE_LOGIN;
 222         return login_write(li);
 223 }
 224
 225
 226 /* login_logout(struct logininfo *)     - Record a logout
 227  *
 228  * Call as with login_login()
 229  *
 230  * Returns:
 231  *  >0 if successful
 232  *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
 233  */
 234 int
 235 login_logout(struct logininfo *li)
 236 {
 237         li->type = LTYPE_LOGOUT;
 238         return login_write(li);
 239 }
 240
 241 /* login_get_lastlog_time(int)           - Retrieve the last login time
 242  *
 243  * Retrieve the last login time for the given uid. Will try to use the
 244  * system lastlog facilities if they are available, but will fall back
 245  * to looking in wtmp/wtmpx if necessary
 246  *
 247  * Returns:
 248  *   0 on failure, or if user has never logged in
 249  *   Time in seconds from the epoch if successful
 250  *
 251  * Useful preprocessor symbols:
 252  *   DISABLE_LASTLOG: If set, *never* even try to retrieve lastlog
 253  *                    info
 254  *   USE_LASTLOG: If set, indicates the presence of system lastlog
 255  *                facilities. If this and DISABLE_LASTLOG are not set,
 256  *                try to retrieve lastlog information from wtmp/wtmpx.
 257  */
 258 unsigned int
 259 login_get_lastlog_time(const int uid)
 260 {
 261         struct logininfo li;
 262
 263         if (login_get_lastlog(&li, uid))
 264                 return li.tv_sec;
 265         else
 266                 return 0;
 267 }
 268
 269 /* login_get_lastlog(struct logininfo *, int)   - Retrieve a lastlog entry
 270  *
 271  * Retrieve a logininfo structure populated (only partially) with
 272  * information from the system lastlog data, or from wtmp/wtmpx if no
 273  * system lastlog information exists.
 274  *
 275  * Note this routine must be given a pre-allocated logininfo.
 276  *
 277  * Returns:
 278  *  >0: A pointer to your struct logininfo if successful
 279  *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
 280  *
 281  */
 282 struct logininfo *
 283 login_get_lastlog(struct logininfo *li, const int uid)
 284 {
 285         struct passwd *pw;
 286
 287         memset(li, '\0', sizeof(*li));
 288         li->uid = uid;
 289
 290         /*
 291          * If we don't have a 'real' lastlog, we need the username to
 292          * reliably search wtmp(x) for the last login (see
 293          * wtmp_get_entry().)
 294          */
 295         pw = getpwuid(uid);
 296         if (pw == NULL)
 297                 fatal("login_get_lastlog: Cannot find account for uid %i", uid);
 298
 299         /* No MIN_SIZEOF here - we absolutely *must not* truncate the
 300          * username */
 301         strlcpy(li->username, pw->pw_name, sizeof(li->username));
 302
 303         if (getlast_entry(li))
 304                 return li;
 305         else
 306                 return NULL;
 307 }
 308
 309
 310 /* login_alloc_entry(int, char*, char*, char*)    - Allocate and initialise
 311  *                                                  a logininfo structure
 312  *
 313  * This function creates a new struct logininfo, a data structure
 314  * meant to carry the information required to portably record login info.
 315  *
 316  * Returns a pointer to a newly created struct logininfo. If memory
 317  * allocation fails, the program halts.
 318  */
 319 struct
 320 logininfo *login_alloc_entry(int pid, const char *username,
 321                              const char *hostname, const char *line)
 322 {
 323         struct logininfo *newli;
 324
 325         newli = (struct logininfo *) xmalloc (sizeof(*newli));
 326         (void)login_init_entry(newli, pid, username, hostname, line);
 327         return newli;
 328 }
 329
 330
 331 /* login_free_entry(struct logininfo *)    - free struct memory */
 332 void
 333 login_free_entry(struct logininfo *li)
 334 {
 335         xfree(li);
 336 }
 337
 338
 339 /* login_init_entry(struct logininfo *, int, char*, char*, char*)
 340  *                                        - initialise a struct logininfo
 341  *
 342  * Populates a new struct logininfo, a data structure meant to carry
 343  * the information required to portably record login info.
 344  *
 345  * Returns: 1
 346  */
 347 int
 348 login_init_entry(struct logininfo *li, int pid, const char *username,
 349                  const char *hostname, const char *line)
 350 {
 351         struct passwd *pw;
 352
 353         memset(li, 0, sizeof(*li));
 354
 355         li->pid = pid;
 356
 357         /* set the line information */
 358         if (line)
 359                 line_fullname(li->line, line, sizeof(li->line));
 360
 361         if (username) {
 362                 strlcpy(li->username, username, sizeof(li->username));
 363                 pw = getpwnam(li->username);
 364                 if (pw == NULL)
 365                         fatal("login_init_entry: Cannot find user \"%s\"", li->username);
 366                 li->uid = pw->pw_uid;
 367         }
 368
 369         if (hostname)
 370                 strlcpy(li->hostname, hostname, sizeof(li->hostname));
 371
 372         return 1;
 373 }
 374
 375 /* login_set_current_time(struct logininfo *)    - set the current time
 376  *
 377  * Set the current time in a logininfo structure. This function is
 378  * meant to eliminate the need to deal with system dependencies for
 379  * time handling.
 380  */
 381 void
 382 login_set_current_time(struct logininfo *li)
 383 {
 384         struct timeval tv;
 385
 386         gettimeofday(&tv, NULL);
 387
 388         li->tv_sec = tv.tv_sec;
 389         li->tv_usec = tv.tv_usec;
 390 }
 391
 392 /* copy a sockaddr_* into our logininfo */
 393 void
 394 login_set_addr(struct logininfo *li, const struct sockaddr *sa,
 395                const unsigned int sa_size)
 396 {
 397         unsigned int bufsize = sa_size;
 398
 399         /* make sure we don't overrun our union */
 400         if (sizeof(li->hostaddr) < sa_size)
 401                 bufsize = sizeof(li->hostaddr);
 402
 403         memcpy((void *)&(li->hostaddr.sa), (const void *)sa, bufsize);
 404 }
 405
 406
 407 /**
 408  ** login_write: Call low-level recording functions based on autoconf
 409  ** results
 410  **/
 411 int
 412 login_write (struct logininfo *li)
 413 {
 414 #ifndef HAVE_CYGWIN
 415         if ((int)geteuid() != 0) {
 416           log("Attempt to write login records by non-root user (aborting)");
 417           return 1;
 418         }
 419 #endif
 420
 421         /* set the timestamp */
 422         login_set_current_time(li);
 423 #ifdef USE_LOGIN
 424         syslogin_write_entry(li);
 425 #endif
 426 #ifdef USE_LASTLOG
 427         if (li->type == LTYPE_LOGIN) {
 428                 lastlog_write_entry(li);
 429         }
 430 #endif
 431 #ifdef USE_UTMP
 432         utmp_write_entry(li);
 433 #endif
 434 #ifdef USE_WTMP
 435         wtmp_write_entry(li);
 436 #endif
 437 #ifdef USE_UTMPX
 438         utmpx_write_entry(li);
 439 #endif
 440 #ifdef USE_WTMPX
 441         wtmpx_write_entry(li);
 442 #endif
 443         return 0;
 444 }
 445
 446 /**
 447  ** getlast_entry: Call low-level functions to retrieve the last login
 448  **                time.
 449  **/
 450
 451 /* take the uid in li and return the last login time */
 452 int
 453 getlast_entry(struct logininfo *li)
 454 {
 455 #ifdef USE_LASTLOG
 456         return(lastlog_get_entry(li));
 457 #else /* !USE_LASTLOG */
 458
 459 #ifdef DISABLE_LASTLOG
 460         /* On some systems we shouldn't even try to obtain last login
 461          * time, e.g. AIX */
 462         return 0;
 463 # else /* DISABLE_LASTLOG */
 464         /* Try to retrieve the last login time from wtmp */
 465 #  if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
 466         /* retrieve last login time from utmp */
 467         return (wtmp_get_entry(li));
 468 #  else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
 469         /* If wtmp isn't available, try wtmpx */
 470 #   if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
 471         /* retrieve last login time from utmpx */
 472         return (wtmpx_get_entry(li));
 473 #   else
 474         /* Give up: No means of retrieving last login time */
 475         return 0;
 476 #   endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
 477 #  endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
 478 # endif /* DISABLE_LASTLOG */
 479 #endif /* USE_LASTLOG */
 480 }
 481
 482
 483
 484 /*
 485  * 'line' string utility functions
 486  *
 487  * These functions process the 'line' string into one of three forms:
 488  *
 489  * 1. The full filename (including '/dev')
 490  * 2. The stripped name (excluding '/dev')
 491  * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
 492  *                               /dev/pts/1  -> ts/1 )
 493  *
 494  * Form 3 is used on some systems to identify a .tmp.? entry when
 495  * attempting to remove it. Typically both addition and removal is
 496  * performed by one application - say, sshd - so as long as the choice
 497  * uniquely identifies a terminal it's ok.
 498  */
 499
 500
 501 /* line_fullname(): add the leading '/dev/' if it doesn't exist make
 502  * sure dst has enough space, if not just copy src (ugh) */
 503 char *
 504 line_fullname(char *dst, const char *src, int dstsize)
 505 {
 506         memset(dst, '\0', dstsize);
 507         if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
 508                 strlcpy(dst, src, dstsize);
 509         } else {
 510                 strlcpy(dst, "/dev/", dstsize);
 511                 strlcat(dst, src, dstsize);
 512         }
 513         return dst;
 514 }
 515
 516 /* line_stripname(): strip the leading '/dev' if it exists, return dst */
 517 char *
 518 line_stripname(char *dst, const char *src, int dstsize)
 519 {
 520         memset(dst, '\0', dstsize);
 521         if (strncmp(src, "/dev/", 5) == 0)
 522                 strlcpy(dst, src + 5, dstsize);
 523         else
 524                 strlcpy(dst, src, dstsize);
 525         return dst;
 526 }
 527
 528 /* line_abbrevname(): Return the abbreviated (usually four-character)
 529  * form of the line (Just use the last <dstsize> characters of the
 530  * full name.)
 531  *
 532  * NOTE: use strncpy because we do NOT necessarily want zero
 533  * termination */
 534 char *
 535 line_abbrevname(char *dst, const char *src, int dstsize)
 536 {
 537         size_t len;
 538
 539         memset(dst, '\0', dstsize);
 540
 541         /* Always skip prefix if present */
 542 #ifdef sgi
 543         if (strncmp(src, "/dev/tty", 8) == 0)
 544                 src += 8;
 545 #else
 546         if (strncmp(src, "/dev/", 5) == 0)
 547                 src += 5;
 548 #endif
 549
 550         len = strlen(src);
 551
 552         if (len > 0) {
 553                 if (((int)len - dstsize) > 0)
 554                         src +=  ((int)len - dstsize);
 555
 556                 /* note: _don't_ change this to strlcpy */
 557                 strncpy(dst, src, (size_t)dstsize);
 558         }
 559
 560         return dst;
 561 }
 562
 563 /**
 564  ** utmp utility functions
 565  **
 566  ** These functions manipulate struct utmp, taking system differences
 567  ** into account.
 568  **/
 569
 570 #if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
 571
 572 /* build the utmp structure */
 573 void
 574 set_utmp_time(struct logininfo *li, struct utmp *ut)
 575 {
 576 # ifdef HAVE_TV_IN_UTMP
 577         ut->ut_tv.tv_sec = li->tv_sec;
 578         ut->ut_tv.tv_usec = li->tv_usec;
 579 # else
 580 #  ifdef HAVE_TIME_IN_UTMP
 581         ut->ut_time = li->tv_sec;
 582 #  endif
 583 # endif
 584 }
 585
 586 void
 587 construct_utmp(struct logininfo *li,
 588                     struct utmp *ut)
 589 {
 590         memset(ut, '\0', sizeof(*ut));
 591
 592         /* First fill out fields used for both logins and logouts */
 593
 594 # ifdef HAVE_ID_IN_UTMP
 595         line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
 596 # endif
 597
 598 # ifdef HAVE_TYPE_IN_UTMP
 599         /* This is done here to keep utmp constants out of struct logininfo */
 600         switch (li->type) {
 601         case LTYPE_LOGIN:
 602                 ut->ut_type = USER_PROCESS;
 603                 break;
 604         case LTYPE_LOGOUT:
 605                 ut->ut_type = DEAD_PROCESS;
 606                 break;
 607         }
 608 # endif
 609         set_utmp_time(li, ut);
 610
 611         line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
 612
 613 # ifdef HAVE_PID_IN_UTMP
 614         ut->ut_pid = li->pid;
 615 # endif
 616
 617         /* If we're logging out, leave all other fields blank */
 618         if (li->type == LTYPE_LOGOUT)
 619           return;
 620
 621         /*
 622          * These fields are only used when logging in, and are blank
 623          * for logouts.
 624          */
 625
 626         /* Use strncpy because we don't necessarily want null termination */
 627         strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
 628 # ifdef HAVE_HOST_IN_UTMP
 629         strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
 630 # endif
 631 # ifdef HAVE_ADDR_IN_UTMP
 632         /* this is just a 32-bit IP address */
 633         if (li->hostaddr.sa.sa_family == AF_INET)
 634                 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
 635 # endif
 636 }
 637 #endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
 638
 639 /**
 640  ** utmpx utility functions
 641  **
 642  ** These functions manipulate struct utmpx, accounting for system
 643  ** variations.
 644  **/
 645
 646 #if defined(USE_UTMPX) || defined (USE_WTMPX)
 647 /* build the utmpx structure */
 648 void
 649 set_utmpx_time(struct logininfo *li, struct utmpx *utx)
 650 {
 651 # ifdef HAVE_TV_IN_UTMPX
 652         utx->ut_tv.tv_sec = li->tv_sec;
 653         utx->ut_tv.tv_usec = li->tv_usec;
 654 # else /* HAVE_TV_IN_UTMPX */
 655 #  ifdef HAVE_TIME_IN_UTMPX
 656         utx->ut_time = li->tv_sec;
 657 #  endif /* HAVE_TIME_IN_UTMPX */
 658 # endif /* HAVE_TV_IN_UTMPX */
 659 }
 660
 661 void
 662 construct_utmpx(struct logininfo *li, struct utmpx *utx)
 663 {
 664         memset(utx, '\0', sizeof(*utx));
 665 # ifdef HAVE_ID_IN_UTMPX
 666         line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
 667 # endif
 668
 669         /* this is done here to keep utmp constants out of loginrec.h */
 670         switch (li->type) {
 671         case LTYPE_LOGIN:
 672                 utx->ut_type = USER_PROCESS;
 673                 break;
 674         case LTYPE_LOGOUT:
 675                 utx->ut_type = DEAD_PROCESS;
 676                 break;
 677         }
 678         line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
 679         set_utmpx_time(li, utx);
 680         utx->ut_pid = li->pid;
 681
 682         if (li->type == LTYPE_LOGOUT)
 683                 return;
 684
 685         /*
 686          * These fields are only used when logging in, and are blank
 687          * for logouts.
 688          */
 689
 690         /* strncpy(): Don't necessarily want null termination */
 691         strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
 692 # ifdef HAVE_HOST_IN_UTMPX
 693         strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
 694 # endif
 695 # ifdef HAVE_ADDR_IN_UTMPX
 696         /* this is just a 32-bit IP address */
 697         if (li->hostaddr.sa.sa_family == AF_INET)
 698                 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
 699 # endif
 700 # ifdef HAVE_SYSLEN_IN_UTMPX
 701         /* ut_syslen is the length of the utx_host string */
 702         utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
 703 # endif
 704 }
 705 #endif /* USE_UTMPX || USE_WTMPX */
 706
 707 /**
 708  ** Low-level utmp functions
 709  **/
 710
 711 /* FIXME: (ATL) utmp_write_direct needs testing */
 712 #ifdef USE_UTMP
 713
 714 /* if we can, use pututline() etc. */
 715 # if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
 716         defined(HAVE_PUTUTLINE)
 717 #  define UTMP_USE_LIBRARY
 718 # endif
 719
 720
 721 /* write a utmp entry with the system's help (pututline() and pals) */
 722 # ifdef UTMP_USE_LIBRARY
 723 static int
 724 utmp_write_library(struct logininfo *li, struct utmp *ut)
 725 {
 726         setutent();
 727         pututline(ut);
 728
 729 #  ifdef HAVE_ENDUTENT
 730         endutent();
 731 #  endif
 732         return 1;
 733 }
 734 # else /* UTMP_USE_LIBRARY */
 735
 736 /* write a utmp entry direct to the file */
 737 /* This is a slightly modification of code in OpenBSD's login.c */
 738 static int
 739 utmp_write_direct(struct logininfo *li, struct utmp *ut)
 740 {
 741         struct utmp old_ut;
 742         register int fd;
 743         int tty;
 744
 745         /* FIXME: (ATL) ttyslot() needs local implementation */
 746
 747 #if defined(HAVE_GETTTYENT)
 748         register struct ttyent *ty;
 749
 750         tty=0;
 751
 752         setttyent();
 753         while ((struct ttyent *)0 != (ty = getttyent())) {
 754                 tty++;
 755                 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
 756                         break;
 757         }
 758         endttyent();
 759
 760         if((struct ttyent *)0 == ty) {
 761                 log("utmp_write_entry: tty not found");
 762                 return(1);
 763         }
 764 #else /* FIXME */
 765
 766         tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
 767
 768 #endif /* HAVE_GETTTYENT */
 769
 770         if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
 771                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
 772                 /*
 773                  * Prevent luser from zero'ing out ut_host.
 774                  * If the new ut_line is empty but the old one is not
 775                  * and ut_line and ut_name match, preserve the old ut_line.
 776                  */
 777                 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
 778                         (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
 779                         (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
 780                         (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
 781                         (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
 782                 }
 783
 784                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
 785                 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
 786                         log("utmp_write_direct: error writing %s: %s",
 787                             UTMP_FILE, strerror(errno));
 788
 789                 (void)close(fd);
 790                 return 1;
 791         } else {
 792                 return 0;
 793         }
 794 }
 795 # endif /* UTMP_USE_LIBRARY */
 796
 797 static int
 798 utmp_perform_login(struct logininfo *li)
 799 {
 800         struct utmp ut;
 801
 802         construct_utmp(li, &ut);
 803 # ifdef UTMP_USE_LIBRARY
 804         if (!utmp_write_library(li, &ut)) {
 805                 log("utmp_perform_login: utmp_write_library() failed");
 806                 return 0;
 807         }
 808 # else
 809         if (!utmp_write_direct(li, &ut)) {
 810                 log("utmp_perform_login: utmp_write_direct() failed");
 811                 return 0;
 812         }
 813 # endif
 814         return 1;
 815 }
 816
 817
 818 static int
 819 utmp_perform_logout(struct logininfo *li)
 820 {
 821         struct utmp ut;
 822
 823         construct_utmp(li, &ut);
 824 # ifdef UTMP_USE_LIBRARY
 825         if (!utmp_write_library(li, &ut)) {
 826                 log("utmp_perform_logout: utmp_write_library() failed");
 827                 return 0;
 828         }
 829 # else
 830         if (!utmp_write_direct(li, &ut)) {
 831                 log("utmp_perform_logout: utmp_write_direct() failed");
 832                 return 0;
 833         }
 834 # endif
 835         return 1;
 836 }
 837
 838
 839 int
 840 utmp_write_entry(struct logininfo *li)
 841 {
 842         switch(li->type) {
 843         case LTYPE_LOGIN:
 844                 return utmp_perform_login(li);
 845
 846         case LTYPE_LOGOUT:
 847                 return utmp_perform_logout(li);
 848
 849         default:
 850                 log("utmp_write_entry: invalid type field");
 851                 return 0;
 852         }
 853 }
 854 #endif /* USE_UTMP */
 855
 856
 857 /**
 858  ** Low-level utmpx functions
 859  **/
 860
 861 /* not much point if we don't want utmpx entries */
 862 #ifdef USE_UTMPX
 863
 864 /* if we have the wherewithall, use pututxline etc. */
 865 # if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
 866         defined(HAVE_PUTUTXLINE)
 867 #  define UTMPX_USE_LIBRARY
 868 # endif
 869
 870
 871 /* write a utmpx entry with the system's help (pututxline() and pals) */
 872 # ifdef UTMPX_USE_LIBRARY
 873 static int
 874 utmpx_write_library(struct logininfo *li, struct utmpx *utx)
 875 {
 876         setutxent();
 877         pututxline(utx);
 878
 879 #  ifdef HAVE_ENDUTXENT
 880         endutxent();
 881 #  endif
 882         return 1;
 883 }
 884
 885 # else /* UTMPX_USE_LIBRARY */
 886
 887 /* write a utmp entry direct to the file */
 888 static int
 889 utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
 890 {
 891         log("utmpx_write_direct: not implemented!");
 892         return 0;
 893 }
 894 # endif /* UTMPX_USE_LIBRARY */
 895
 896 static int
 897 utmpx_perform_login(struct logininfo *li)
 898 {
 899         struct utmpx utx;
 900
 901         construct_utmpx(li, &utx);
 902 # ifdef UTMPX_USE_LIBRARY
 903         if (!utmpx_write_library(li, &utx)) {
 904                 log("utmpx_perform_login: utmp_write_library() failed");
 905                 return 0;
 906         }
 907 # else
 908         if (!utmpx_write_direct(li, &ut)) {
 909                 log("utmpx_perform_login: utmp_write_direct() failed");
 910                 return 0;
 911         }
 912 # endif
 913         return 1;
 914 }
 915
 916
 917 static int
 918 utmpx_perform_logout(struct logininfo *li)
 919 {
 920         struct utmpx utx;
 921
 922         memset(&utx, '\0', sizeof(utx));
 923         set_utmpx_time(li, &utx);
 924         line_stripname(utx.ut_line, li->line, sizeof(utx.ut_line));
 925 # ifdef HAVE_ID_IN_UTMPX
 926         line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
 927 # endif
 928 # ifdef HAVE_TYPE_IN_UTMPX
 929         utx.ut_type = DEAD_PROCESS;
 930 # endif
 931
 932 # ifdef UTMPX_USE_LIBRARY
 933         utmpx_write_library(li, &utx);
 934 # else
 935         utmpx_write_direct(li, &utx);
 936 # endif
 937         return 1;
 938 }
 939
 940 int
 941 utmpx_write_entry(struct logininfo *li)
 942 {
 943         switch(li->type) {
 944         case LTYPE_LOGIN:
 945                 return utmpx_perform_login(li);
 946         case LTYPE_LOGOUT:
 947                 return utmpx_perform_logout(li);
 948         default:
 949                 log("utmpx_write_entry: invalid type field");
 950                 return 0;
 951         }
 952 }
 953 #endif /* USE_UTMPX */
 954
 955
 956 /**
 957  ** Low-level wtmp functions
 958  **/
 959
 960 #ifdef USE_WTMP
 961
 962 /* write a wtmp entry direct to the end of the file */
 963 /* This is a slight modification of code in OpenBSD's logwtmp.c */
 964 static int
 965 wtmp_write(struct logininfo *li, struct utmp *ut)
 966 {
 967         struct stat buf;
 968         int fd, ret = 1;
 969
 970         if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
 971                 log("wtmp_write: problem writing %s: %s",
 972                     WTMP_FILE, strerror(errno));
 973                 return 0;
 974         }
 975         if (fstat(fd, &buf) == 0)
 976                 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
 977                         ftruncate(fd, buf.st_size);
 978                         log("wtmp_write: problem writing %s: %s",
 979                             WTMP_FILE, strerror(errno));
 980                         ret = 0;
 981                 }
 982         (void)close(fd);
 983         return ret;
 984 }
 985
 986 static int
 987 wtmp_perform_login(struct logininfo *li)
 988 {
 989         struct utmp ut;
 990
 991         construct_utmp(li, &ut);
 992         return wtmp_write(li, &ut);
 993 }
 994
 995
 996 static int
 997 wtmp_perform_logout(struct logininfo *li)
 998 {
 999         struct utmp ut;
1000
1001         construct_utmp(li, &ut);
1002         return wtmp_write(li, &ut);
1003 }
1004
1005
1006 int
1007 wtmp_write_entry(struct logininfo *li)
1008 {
1009         switch(li->type) {
1010         case LTYPE_LOGIN:
1011                 return wtmp_perform_login(li);
1012         case LTYPE_LOGOUT:
1013                 return wtmp_perform_logout(li);
1014         default:
1015                 log("wtmp_write_entry: invalid type field");
1016                 return 0;
1017         }
1018 }
1019
1020
1021 /* Notes on fetching login data from wtmp/wtmpx
1022  *
1023  * Logouts are usually recorded with (amongst other things) a blank
1024  * username on a given tty line.  However, some systems (HP-UX is one)
1025  * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1026  *
1027  * Since we're only looking for logins here, we know that the username
1028  * must be set correctly. On systems that leave it in, we check for
1029  * ut_type==USER_PROCESS (indicating a login.)
1030  *
1031  * Portability: Some systems may set something other than USER_PROCESS
1032  * to indicate a login process. I don't know of any as I write. Also,
1033  * it's possible that some systems may both leave the username in
1034  * place and not have ut_type.
1035  */
1036
1037 /* return true if this wtmp entry indicates a login */
1038 static int
1039 wtmp_islogin(struct logininfo *li, struct utmp *ut)
1040 {
1041         if (strncmp(li->username, ut->ut_name,
1042                 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
1043 # ifdef HAVE_TYPE_IN_UTMP
1044                 if (ut->ut_type & USER_PROCESS)
1045                         return 1;
1046 # else
1047                 return 1;
1048 # endif
1049         }
1050         return 0;
1051 }
1052
1053 int
1054 wtmp_get_entry(struct logininfo *li)
1055 {
1056         struct stat st;
1057         struct utmp ut;
1058         int fd, found=0;
1059
1060         /* Clear the time entries in our logininfo */
1061         li->tv_sec = li->tv_usec = 0;
1062
1063         if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1064                 log("wtmp_get_entry: problem opening %s: %s",
1065                     WTMP_FILE, strerror(errno));
1066                 return 0;
1067         }
1068         if (fstat(fd, &st) != 0) {
1069                 log("wtmp_get_entry: couldn't stat %s: %s",
1070                     WTMP_FILE, strerror(errno));
1071                 close(fd);
1072                 return 0;
1073         }
1074
1075         /* Seek to the start of the last struct utmp */
1076         if (lseek(fd, (off_t)(0 - sizeof(struct utmp)), SEEK_END) == -1) {
1077                 /* Looks like we've got a fresh wtmp file */
1078                 close(fd);
1079                 return 0;
1080         }
1081
1082         while (!found) {
1083                 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
1084                         log("wtmp_get_entry: read of %s failed: %s",
1085                             WTMP_FILE, strerror(errno));
1086                         close (fd);
1087                         return 0;
1088                 }
1089                 if ( wtmp_islogin(li, &ut) ) {
1090                         found = 1;
1091                         /* We've already checked for a time in struct
1092                          * utmp, in login_getlast(). */
1093 # ifdef HAVE_TIME_IN_UTMP
1094                         li->tv_sec = ut.ut_time;
1095 # else
1096 #  if HAVE_TV_IN_UTMP
1097                         li->tv_sec = ut.ut_tv.tv_sec;
1098 #  endif
1099 # endif
1100                         line_fullname(li->line, ut.ut_line,
1101                                       MIN_SIZEOF(li->line, ut.ut_line));
1102 # ifdef HAVE_HOST_IN_UTMP
1103                         strlcpy(li->hostname, ut.ut_host,
1104                                 MIN_SIZEOF(li->hostname, ut.ut_host));
1105 # endif
1106                         continue;
1107                 }
1108                 /* Seek back 2 x struct utmp */
1109                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmp)), SEEK_CUR) == -1) {
1110                         /* We've found the start of the file, so quit */
1111                         close (fd);
1112                         return 0;
1113                 }
1114         }
1115
1116         /* We found an entry. Tidy up and return */
1117         close(fd);
1118         return 1;
1119 }
1120 # endif /* USE_WTMP */
1121
1122
1123 /**
1124  ** Low-level wtmpx functions
1125  **/
1126
1127 #ifdef USE_WTMPX
1128 /* write a wtmpx entry direct to the end of the file */
1129 /* This is a slight modification of code in OpenBSD's logwtmp.c */
1130 static int
1131 wtmpx_write(struct logininfo *li, struct utmpx *utx)
1132 {
1133         struct stat buf;
1134         int fd, ret = 1;
1135
1136         if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1137                 log("wtmpx_write: problem opening %s: %s",
1138                     WTMPX_FILE, strerror(errno));
1139                 return 0;
1140         }
1141
1142         if (fstat(fd, &buf) == 0)
1143                 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
1144                         ftruncate(fd, buf.st_size);
1145                         log("wtmpx_write: problem writing %s: %s",
1146                             WTMPX_FILE, strerror(errno));
1147                         ret = 0;
1148                 }
1149         (void)close(fd);
1150
1151         return ret;
1152 }
1153
1154
1155 static int
1156 wtmpx_perform_login(struct logininfo *li)
1157 {
1158         struct utmpx utx;
1159
1160         construct_utmpx(li, &utx);
1161         return wtmpx_write(li, &utx);
1162 }
1163
1164
1165 static int
1166 wtmpx_perform_logout(struct logininfo *li)
1167 {
1168         struct utmpx utx;
1169
1170         construct_utmpx(li, &utx);
1171         return wtmpx_write(li, &utx);
1172 }
1173
1174
1175 int
1176 wtmpx_write_entry(struct logininfo *li)
1177 {
1178         switch(li->type) {
1179         case LTYPE_LOGIN:
1180                 return wtmpx_perform_login(li);
1181         case LTYPE_LOGOUT:
1182                 return wtmpx_perform_logout(li);
1183         default:
1184                 log("wtmpx_write_entry: invalid type field");
1185                 return 0;
1186         }
1187 }
1188
1189 /* Please see the notes above wtmp_islogin() for information about the
1190    next two functions */
1191
1192 /* Return true if this wtmpx entry indicates a login */
1193 static int
1194 wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1195 {
1196         if ( strncmp(li->username, utx->ut_name,
1197                 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
1198 # ifdef HAVE_TYPE_IN_UTMPX
1199                 if (utx->ut_type == USER_PROCESS)
1200                         return 1;
1201 # else
1202                 return 1;
1203 # endif
1204         }
1205         return 0;
1206 }
1207
1208
1209 int
1210 wtmpx_get_entry(struct logininfo *li)
1211 {
1212         struct stat st;
1213         struct utmpx utx;
1214         int fd, found=0;
1215
1216         /* Clear the time entries */
1217         li->tv_sec = li->tv_usec = 0;
1218
1219         if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1220                 log("wtmpx_get_entry: problem opening %s: %s",
1221                     WTMPX_FILE, strerror(errno));
1222                 return 0;
1223         }
1224         if (fstat(fd, &st) != 0) {
1225                 log("wtmpx_get_entry: couldn't stat %s: %s",
1226                     WTMP_FILE, strerror(errno));
1227                 close(fd);
1228                 return 0;
1229         }
1230
1231         /* Seek to the start of the last struct utmpx */
1232         if (lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END) == -1 ) {
1233                 /* probably a newly rotated wtmpx file */
1234                 close(fd);
1235                 return 0;
1236         }
1237
1238         while (!found) {
1239                 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
1240                         log("wtmpx_get_entry: read of %s failed: %s",
1241                             WTMPX_FILE, strerror(errno));
1242                         close (fd);
1243                         return 0;
1244                 }
1245                 /* Logouts are recorded as a blank username on a particular line.
1246                  * So, we just need to find the username in struct utmpx */
1247                 if ( wtmpx_islogin(li, &utx) ) {
1248 # ifdef HAVE_TV_IN_UTMPX
1249                         li->tv_sec = utx.ut_tv.tv_sec;
1250 # else
1251 #  ifdef HAVE_TIME_IN_UTMPX
1252                         li->tv_sec = utx.ut_time;
1253 #  endif
1254 # endif
1255                         line_fullname(li->line, utx.ut_line, sizeof(li->line));
1256 # ifdef HAVE_HOST_IN_UTMPX
1257                         strlcpy(li->hostname, utx.ut_host,
1258                                 MIN_SIZEOF(li->hostname, utx.ut_host));
1259 # endif
1260                         continue;
1261                 }
1262                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmpx)), SEEK_CUR) == -1) {
1263                         close (fd);
1264                         return 0;
1265                 }
1266         }
1267
1268         close(fd);
1269         return 1;
1270 }
1271 #endif /* USE_WTMPX */
1272
1273 /**
1274  ** Low-level libutil login() functions
1275  **/
1276
1277 #ifdef USE_LOGIN
1278 static int
1279 syslogin_perform_login(struct logininfo *li)
1280 {
1281         struct utmp *ut;
1282
1283         if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
1284                 log("syslogin_perform_login: couldn't malloc()");
1285                 return 0;
1286         }
1287         construct_utmp(li, ut);
1288         login(ut);
1289
1290         return 1;
1291 }
1292
1293 static int
1294 syslogin_perform_logout(struct logininfo *li)
1295 {
1296 # ifdef HAVE_LOGOUT
1297         char line[8];
1298
1299         (void)line_stripname(line, li->line, sizeof(line));
1300
1301         if (!logout(line)) {
1302                 log("syslogin_perform_logout: logout() returned an error");
1303 #  ifdef HAVE_LOGWTMP
1304         } else {
1305                 logwtmp(line, "", "");
1306 #  endif
1307         }
1308         /* FIXME: (ATL - if the need arises) What to do if we have
1309          * login, but no logout?  what if logout but no logwtmp? All
1310          * routines are in libutil so they should all be there,
1311          * but... */
1312 # endif
1313         return 1;
1314 }
1315
1316 int
1317 syslogin_write_entry(struct logininfo *li)
1318 {
1319         switch (li->type) {
1320         case LTYPE_LOGIN:
1321                 return syslogin_perform_login(li);
1322         case LTYPE_LOGOUT:
1323                 return syslogin_perform_logout(li);
1324         default:
1325                 log("syslogin_write_entry: Invalid type field");
1326                 return 0;
1327         }
1328 }
1329 #endif /* USE_LOGIN */
1330
1331 /* end of file log-syslogin.c */
1332
1333 /**
1334  ** Low-level lastlog functions
1335  **/
1336
1337 #ifdef USE_LASTLOG
1338 #define LL_FILE 1
1339 #define LL_DIR 2
1340 #define LL_OTHER 3
1341
1342 static void
1343 lastlog_construct(struct logininfo *li, struct lastlog *last)
1344 {
1345         /* clear the structure */
1346         memset(last, '\0', sizeof(*last));
1347
1348         (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
1349         strlcpy(last->ll_host, li->hostname,
1350                 MIN_SIZEOF(last->ll_host, li->hostname));
1351         last->ll_time = li->tv_sec;
1352 }
1353
1354 static int
1355 lastlog_filetype(char *filename)
1356 {
1357         struct stat st;
1358
1359         if (stat(LASTLOG_FILE, &st) != 0) {
1360                 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
1361                         strerror(errno));
1362                 return 0;
1363         }
1364         if (S_ISDIR(st.st_mode))
1365                 return LL_DIR;
1366         else if (S_ISREG(st.st_mode))
1367                 return LL_FILE;
1368         else
1369                 return LL_OTHER;
1370 }
1371
1372
1373 /* open the file (using filemode) and seek to the login entry */
1374 static int
1375 lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1376 {
1377         off_t offset;
1378         int type;
1379         char lastlog_file[1024];
1380
1381         type = lastlog_filetype(LASTLOG_FILE);
1382         switch (type) {
1383                 case LL_FILE:
1384                         strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1385                         break;
1386                 case LL_DIR:
1387                         snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1388                                  LASTLOG_FILE, li->username);
1389                         break;
1390                 default:
1391                         log("lastlog_openseek: %.100s is not a file or directory!",
1392                             LASTLOG_FILE);
1393                         return 0;
1394         }
1395
1396         *fd = open(lastlog_file, filemode);
1397         if ( *fd < 0) {
1398                 debug("lastlog_openseek: Couldn't open %s: %s",
1399                     lastlog_file, strerror(errno));
1400                 return 0;
1401         }
1402
1403         if (type == LL_FILE) {
1404                 /* find this uid's offset in the lastlog file */
1405                 offset = (off_t) ( (long)li->uid * sizeof(struct lastlog));
1406
1407                 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1408                         log("lastlog_openseek: %s->lseek(): %s",
1409                          lastlog_file, strerror(errno));
1410                         return 0;
1411                 }
1412         }
1413
1414         return 1;
1415 }
1416
1417 static int
1418 lastlog_perform_login(struct logininfo *li)
1419 {
1420         struct lastlog last;
1421         int fd;
1422
1423         /* create our struct lastlog */
1424         lastlog_construct(li, &last);
1425
1426         if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1427                 return(0);
1428
1429         /* write the entry */
1430         if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1431                 close(fd);
1432                 log("lastlog_write_filemode: Error writing to %s: %s",
1433                     LASTLOG_FILE, strerror(errno));
1434                 return 0;
1435         }
1436
1437         close(fd);
1438         return 1;
1439 }
1440
1441 int
1442 lastlog_write_entry(struct logininfo *li)
1443 {
1444         switch(li->type) {
1445         case LTYPE_LOGIN:
1446                 return lastlog_perform_login(li);
1447         default:
1448                 log("lastlog_write_entry: Invalid type field");
1449                 return 0;
1450         }
1451 }
1452
1453 static void
1454 lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1455 {
1456         line_fullname(li->line, last->ll_line, sizeof(li->line));
1457         strlcpy(li->hostname, last->ll_host,
1458                 MIN_SIZEOF(li->hostname, last->ll_host));
1459         li->tv_sec = last->ll_time;
1460 }
1461
1462 int
1463 lastlog_get_entry(struct logininfo *li)
1464 {
1465         struct lastlog last;
1466         int fd;
1467
1468         if (lastlog_openseek(li, &fd, O_RDONLY)) {
1469                 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1470                         log("lastlog_get_entry: Error reading from %s: %s",
1471                             LASTLOG_FILE, strerror(errno));
1472                         return 0;
1473                 } else {
1474                         lastlog_populate_entry(li, &last);
1475                         return 1;
1476                 }
1477         } else {
1478                 return 0;
1479         }
1480 }
1481 #endif /* USE_LASTLOG */