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
 164 RCSID("$Id$");
 165
 166 #ifdef HAVE_UTIL_H
 167 #  include <util.h>
 168 #endif
 169
 170 /**
 171  ** prototypes for helper functions in this file
 172  **/
 173
 174 #if HAVE_UTMP_H
 175 void set_utmp_time(struct logininfo *li, struct utmp *ut);
 176 void construct_utmp(struct logininfo *li, struct utmp *ut);
 177 #endif
 178
 179 #ifdef HAVE_UTMPX_H
 180 void set_utmpx_time(struct logininfo *li, struct utmpx *ut);
 181 void construct_utmpx(struct logininfo *li, struct utmpx *ut);
 182 #endif
 183
 184 int utmp_write_entry(struct logininfo *li);
 185 int utmpx_write_entry(struct logininfo *li);
 186 int wtmp_write_entry(struct logininfo *li);
 187 int wtmpx_write_entry(struct logininfo *li);
 188 int lastlog_write_entry(struct logininfo *li);
 189 int syslogin_write_entry(struct logininfo *li);
 190
 191 int getlast_entry(struct logininfo *li);
 192 int lastlog_get_entry(struct logininfo *li);
 193 int wtmp_get_entry(struct logininfo *li);
 194 int wtmpx_get_entry(struct logininfo *li);
 195
 196 /* pick the shortest string */
 197 #define MIN_SIZEOF(s1,s2) ( sizeof(s1) < sizeof(s2) ? sizeof(s1) : sizeof(s2) )
 198
 199 /**
 200  ** platform-independent login functions
 201  **/
 202
 203 /* login_login(struct logininfo *)     -Record a login
 204  *
 205  * Call with a pointer to a struct logininfo initialised with
 206  * login_init_entry() or login_alloc_entry()
 207  *
 208  * Returns:
 209  *  >0 if successful
 210  *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
 211  */
 212 int
 213 login_login (struct logininfo *li)
 214 {
 215         li->type = LTYPE_LOGIN;
 216         return login_write(li);
 217 }
 218
 219
 220 /* login_logout(struct logininfo *)     - Record a logout
 221  *
 222  * Call as with login_login()
 223  *
 224  * Returns:
 225  *  >0 if successful
 226  *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
 227  */
 228 int
 229 login_logout(struct logininfo *li)
 230 {
 231         li->type = LTYPE_LOGOUT;
 232         return login_write(li);
 233 }
 234
 235 /* login_get_lastlog_time(int)           - Retrieve the last login time
 236  *
 237  * Retrieve the last login time for the given uid. Will try to use the
 238  * system lastlog facilities if they are available, but will fall back
 239  * to looking in wtmp/wtmpx if necessary
 240  *
 241  * Returns:
 242  *   0 on failure, or if user has never logged in
 243  *   Time in seconds from the epoch if successful
 244  *
 245  * Useful preprocessor symbols:
 246  *   DISABLE_LASTLOG: If set, *never* even try to retrieve lastlog
 247  *                    info
 248  *   USE_LASTLOG: If set, indicates the presence of system lastlog
 249  *                facilities. If this and DISABLE_LASTLOG are not set,
 250  *                try to retrieve lastlog information from wtmp/wtmpx.
 251  */
 252 unsigned int
 253 login_get_lastlog_time(const int uid)
 254 {
 255         struct logininfo li;
 256
 257         if (login_get_lastlog(&li, uid))
 258                 return li.tv_sec;
 259         else
 260                 return 0;
 261 }
 262
 263 /* login_get_lastlog(struct logininfo *, int)   - Retrieve a lastlog entry
 264  *
 265  * Retrieve a logininfo structure populated (only partially) with
 266  * information from the system lastlog data, or from wtmp/wtmpx if no
 267  * system lastlog information exists.
 268  *
 269  * Note this routine must be given a pre-allocated logininfo.
 270  *
 271  * Returns:
 272  *  >0: A pointer to your struct logininfo if successful
 273  *  0  on failure (will use OpenSSH's logging facilities for diagnostics)
 274  *
 275  */
 276 struct logininfo *
 277 login_get_lastlog(struct logininfo *li, const int uid)
 278 {
 279         struct passwd *pw;
 280
 281         memset(li, '\0', sizeof(*li));
 282         li->uid = uid;
 283
 284         /*
 285          * If we don't have a 'real' lastlog, we need the username to
 286          * reliably search wtmp(x) for the last login (see
 287          * wtmp_get_entry().)
 288          */
 289         pw = getpwuid(uid);
 290         if (pw == NULL)
 291                 fatal("login_get_lastlog: Cannot find account for uid %i", uid);
 292
 293         /* No MIN_SIZEOF here - we absolutely *must not* truncate the
 294          * username */
 295         strlcpy(li->username, pw->pw_name, sizeof(li->username));
 296
 297         if (getlast_entry(li))
 298                 return li;
 299         else
 300                 return NULL;
 301 }
 302
 303
 304 /* login_alloc_entry(int, char*, char*, char*)    - Allocate and initialise
 305  *                                                  a logininfo structure
 306  *
 307  * This function creates a new struct logininfo, a data structure
 308  * meant to carry the information required to portably record login info.
 309  *
 310  * Returns a pointer to a newly created struct logininfo. If memory
 311  * allocation fails, the program halts.
 312  */
 313 struct
 314 logininfo *login_alloc_entry(int pid, const char *username,
 315                              const char *hostname, const char *line)
 316 {
 317         struct logininfo *newli;
 318
 319         newli = (struct logininfo *) xmalloc (sizeof(*newli));
 320         (void)login_init_entry(newli, pid, username, hostname, line);
 321         return newli;
 322 }
 323
 324
 325 /* login_free_entry(struct logininfo *)    - free struct memory */
 326 void
 327 login_free_entry(struct logininfo *li)
 328 {
 329         xfree(li);
 330 }
 331
 332
 333 /* login_init_entry(struct logininfo *, int, char*, char*, char*)
 334  *                                        - initialise a struct logininfo
 335  *
 336  * Populates a new struct logininfo, a data structure meant to carry
 337  * the information required to portably record login info.
 338  *
 339  * Returns: 1
 340  */
 341 int
 342 login_init_entry(struct logininfo *li, int pid, const char *username,
 343                  const char *hostname, const char *line)
 344 {
 345         struct passwd *pw;
 346
 347         memset(li, 0, sizeof(*li));
 348
 349         li->pid = pid;
 350
 351         /* set the line information */
 352         if (line)
 353                 line_fullname(li->line, line, sizeof(li->line));
 354
 355         if (username) {
 356                 strlcpy(li->username, username, sizeof(li->username));
 357                 pw = getpwnam(li->username);
 358                 if (pw == NULL)
 359                         fatal("login_init_entry: Cannot find user \"%s\"", li->username);
 360                 li->uid = pw->pw_uid;
 361         }
 362
 363         if (hostname)
 364                 strlcpy(li->hostname, hostname, sizeof(li->hostname));
 365
 366         return 1;
 367 }
 368
 369 /* login_set_current_time(struct logininfo *)    - set the current time
 370  *
 371  * Set the current time in a logininfo structure. This function is
 372  * meant to eliminate the need to deal with system dependencies for
 373  * time handling.
 374  */
 375 void
 376 login_set_current_time(struct logininfo *li)
 377 {
 378         struct timeval tv;
 379
 380         gettimeofday(&tv, NULL);
 381
 382         li->tv_sec = tv.tv_sec;
 383         li->tv_usec = tv.tv_usec;
 384 }
 385
 386 /* copy a sockaddr_* into our logininfo */
 387 void
 388 login_set_addr(struct logininfo *li, const struct sockaddr *sa,
 389                const unsigned int sa_size)
 390 {
 391         unsigned int bufsize = sa_size;
 392
 393         /* make sure we don't overrun our union */
 394         if (sizeof(li->hostaddr) < sa_size)
 395                 bufsize = sizeof(li->hostaddr);
 396
 397         memcpy((void *)&(li->hostaddr.sa), (const void *)sa, bufsize);
 398 }
 399
 400
 401 /**
 402  ** login_write: Call low-level recording functions based on autoconf
 403  ** results
 404  **/
 405 int
 406 login_write (struct logininfo *li)
 407 {
 408 #ifndef HAVE_CYGWIN
 409         if ((int)geteuid() != 0) {
 410           log("Attempt to write login records by non-root user (aborting)");
 411           return 1;
 412         }
 413 #endif
 414
 415         /* set the timestamp */
 416         login_set_current_time(li);
 417 #ifdef USE_LOGIN
 418         syslogin_write_entry(li);
 419 #endif
 420 #ifdef USE_LASTLOG
 421         if (li->type == LTYPE_LOGIN) {
 422                 lastlog_write_entry(li);
 423         }
 424 #endif
 425 #ifdef USE_UTMP
 426         utmp_write_entry(li);
 427 #endif
 428 #ifdef USE_WTMP
 429         wtmp_write_entry(li);
 430 #endif
 431 #ifdef USE_UTMPX
 432         utmpx_write_entry(li);
 433 #endif
 434 #ifdef USE_WTMPX
 435         wtmpx_write_entry(li);
 436 #endif
 437         return 0;
 438 }
 439
 440 /**
 441  ** getlast_entry: Call low-level functions to retrieve the last login
 442  **                time.
 443  **/
 444
 445 /* take the uid in li and return the last login time */
 446 int
 447 getlast_entry(struct logininfo *li)
 448 {
 449 #ifdef USE_LASTLOG
 450         return(lastlog_get_entry(li));
 451 #else /* !USE_LASTLOG */
 452
 453 #ifdef DISABLE_LASTLOG
 454         /* On some systems we shouldn't even try to obtain last login
 455          * time, e.g. AIX */
 456         return 0;
 457 # else /* DISABLE_LASTLOG */
 458         /* Try to retrieve the last login time from wtmp */
 459 #  if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
 460         /* retrieve last login time from utmp */
 461         return (wtmp_get_entry(li));
 462 #  else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
 463         /* If wtmp isn't available, try wtmpx */
 464 #   if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
 465         /* retrieve last login time from utmpx */
 466         return (wtmpx_get_entry(li));
 467 #   else
 468         /* Give up: No means of retrieving last login time */
 469         return 0;
 470 #   endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
 471 #  endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
 472 # endif /* DISABLE_LASTLOG */
 473 #endif /* USE_LASTLOG */
 474 }
 475
 476
 477
 478 /*
 479  * 'line' string utility functions
 480  *
 481  * These functions process the 'line' string into one of three forms:
 482  *
 483  * 1. The full filename (including '/dev')
 484  * 2. The stripped name (excluding '/dev')
 485  * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
 486  *                               /dev/pts/1  -> ts/1 )
 487  *
 488  * Form 3 is used on some systems to identify a .tmp.? entry when
 489  * attempting to remove it. Typically both addition and removal is
 490  * performed by one application - say, sshd - so as long as the choice
 491  * uniquely identifies a terminal it's ok.
 492  */
 493
 494
 495 /* line_fullname(): add the leading '/dev/' if it doesn't exist make
 496  * sure dst has enough space, if not just copy src (ugh) */
 497 char *
 498 line_fullname(char *dst, const char *src, int dstsize)
 499 {
 500         memset(dst, '\0', dstsize);
 501         if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
 502                 strlcpy(dst, src, dstsize);
 503         } else {
 504                 strlcpy(dst, "/dev/", dstsize);
 505                 strlcat(dst, src, dstsize);
 506         }
 507         return dst;
 508 }
 509
 510 /* line_stripname(): strip the leading '/dev' if it exists, return dst */
 511 char *
 512 line_stripname(char *dst, const char *src, int dstsize)
 513 {
 514         memset(dst, '\0', dstsize);
 515         if (strncmp(src, "/dev/", 5) == 0)
 516                 strlcpy(dst, src + 5, dstsize);
 517         else
 518                 strlcpy(dst, src, dstsize);
 519         return dst;
 520 }
 521
 522 /* line_abbrevname(): Return the abbreviated (usually four-character)
 523  * form of the line (Just use the last <dstsize> characters of the
 524  * full name.)
 525  *
 526  * NOTE: use strncpy because we do NOT necessarily want zero
 527  * termination */
 528 char *
 529 line_abbrevname(char *dst, const char *src, int dstsize)
 530 {
 531         size_t len;
 532
 533         memset(dst, '\0', dstsize);
 534
 535         /* Always skip prefix if present */
 536 #ifdef sgi
 537         if (strncmp(src, "/dev/tty", 8) == 0)
 538                 src += 8;
 539 #else
 540         if (strncmp(src, "/dev/", 5) == 0)
 541                 src += 5;
 542 #endif
 543
 544         len = strlen(src);
 545
 546         if (len > 0) {
 547                 if (((int)len - dstsize) > 0)
 548                         src +=  ((int)len - dstsize);
 549
 550                 /* note: _don't_ change this to strlcpy */
 551                 strncpy(dst, src, (size_t)dstsize);
 552         }
 553
 554         return dst;
 555 }
 556
 557 /**
 558  ** utmp utility functions
 559  **
 560  ** These functions manipulate struct utmp, taking system differences
 561  ** into account.
 562  **/
 563
 564 #if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
 565
 566 /* build the utmp structure */
 567 void
 568 set_utmp_time(struct logininfo *li, struct utmp *ut)
 569 {
 570 # ifdef HAVE_TV_IN_UTMP
 571         ut->ut_tv.tv_sec = li->tv_sec;
 572         ut->ut_tv.tv_usec = li->tv_usec;
 573 # else
 574 #  ifdef HAVE_TIME_IN_UTMP
 575         ut->ut_time = li->tv_sec;
 576 #  endif
 577 # endif
 578 }
 579
 580 void
 581 construct_utmp(struct logininfo *li,
 582                     struct utmp *ut)
 583 {
 584         memset(ut, '\0', sizeof(*ut));
 585
 586         /* First fill out fields used for both logins and logouts */
 587
 588 # ifdef HAVE_ID_IN_UTMP
 589         line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
 590 # endif
 591
 592 # ifdef HAVE_TYPE_IN_UTMP
 593         /* This is done here to keep utmp constants out of struct logininfo */
 594         switch (li->type) {
 595         case LTYPE_LOGIN:
 596                 ut->ut_type = USER_PROCESS;
 597                 break;
 598         case LTYPE_LOGOUT:
 599                 ut->ut_type = DEAD_PROCESS;
 600                 break;
 601         }
 602 # endif
 603         set_utmp_time(li, ut);
 604
 605         line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
 606
 607 # ifdef HAVE_PID_IN_UTMP
 608         ut->ut_pid = li->pid;
 609 # endif
 610
 611         /* If we're logging out, leave all other fields blank */
 612         if (li->type == LTYPE_LOGOUT)
 613           return;
 614
 615         /*
 616          * These fields are only used when logging in, and are blank
 617          * for logouts.
 618          */
 619
 620         /* Use strncpy because we don't necessarily want null termination */
 621         strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
 622 # ifdef HAVE_HOST_IN_UTMP
 623         strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
 624 # endif
 625 # ifdef HAVE_ADDR_IN_UTMP
 626         /* this is just a 32-bit IP address */
 627         if (li->hostaddr.sa.sa_family == AF_INET)
 628                 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
 629 # endif
 630 }
 631 #endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
 632
 633 /**
 634  ** utmpx utility functions
 635  **
 636  ** These functions manipulate struct utmpx, accounting for system
 637  ** variations.
 638  **/
 639
 640 #if defined(USE_UTMPX) || defined (USE_WTMPX)
 641 /* build the utmpx structure */
 642 void
 643 set_utmpx_time(struct logininfo *li, struct utmpx *utx)
 644 {
 645 # ifdef HAVE_TV_IN_UTMPX
 646         utx->ut_tv.tv_sec = li->tv_sec;
 647         utx->ut_tv.tv_usec = li->tv_usec;
 648 # else /* HAVE_TV_IN_UTMPX */
 649 #  ifdef HAVE_TIME_IN_UTMPX
 650         utx->ut_time = li->tv_sec;
 651 #  endif /* HAVE_TIME_IN_UTMPX */
 652 # endif /* HAVE_TV_IN_UTMPX */
 653 }
 654
 655 void
 656 construct_utmpx(struct logininfo *li, struct utmpx *utx)
 657 {
 658         memset(utx, '\0', sizeof(*utx));
 659 # ifdef HAVE_ID_IN_UTMPX
 660         line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
 661 # endif
 662
 663         /* this is done here to keep utmp constants out of loginrec.h */
 664         switch (li->type) {
 665         case LTYPE_LOGIN:
 666                 utx->ut_type = USER_PROCESS;
 667                 break;
 668         case LTYPE_LOGOUT:
 669                 utx->ut_type = DEAD_PROCESS;
 670                 break;
 671         }
 672         line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
 673         set_utmpx_time(li, utx);
 674         utx->ut_pid = li->pid;
 675
 676         if (li->type == LTYPE_LOGOUT)
 677                 return;
 678
 679         /*
 680          * These fields are only used when logging in, and are blank
 681          * for logouts.
 682          */
 683
 684         /* strncpy(): Don't necessarily want null termination */
 685         strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
 686 # ifdef HAVE_HOST_IN_UTMPX
 687         strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
 688 # endif
 689 # ifdef HAVE_ADDR_IN_UTMPX
 690         /* this is just a 32-bit IP address */
 691         if (li->hostaddr.sa.sa_family == AF_INET)
 692                 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
 693 # endif
 694 # ifdef HAVE_SYSLEN_IN_UTMPX
 695         /* ut_syslen is the length of the utx_host string */
 696         utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
 697 # endif
 698 }
 699 #endif /* USE_UTMPX || USE_WTMPX */
 700
 701 /**
 702  ** Low-level utmp functions
 703  **/
 704
 705 /* FIXME: (ATL) utmp_write_direct needs testing */
 706 #ifdef USE_UTMP
 707
 708 /* if we can, use pututline() etc. */
 709 # if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
 710         defined(HAVE_PUTUTLINE)
 711 #  define UTMP_USE_LIBRARY
 712 # endif
 713
 714
 715 /* write a utmp entry with the system's help (pututline() and pals) */
 716 # ifdef UTMP_USE_LIBRARY
 717 static int
 718 utmp_write_library(struct logininfo *li, struct utmp *ut)
 719 {
 720         setutent();
 721         pututline(ut);
 722
 723 #  ifdef HAVE_ENDUTENT
 724         endutent();
 725 #  endif
 726         return 1;
 727 }
 728 # else /* UTMP_USE_LIBRARY */
 729
 730 /* write a utmp entry direct to the file */
 731 /* This is a slightly modification of code in OpenBSD's login.c */
 732 static int
 733 utmp_write_direct(struct logininfo *li, struct utmp *ut)
 734 {
 735         struct utmp old_ut;
 736         register int fd;
 737         int tty;
 738
 739         /* FIXME: (ATL) ttyslot() needs local implementation */
 740
 741 #if defined(HAVE_GETTTYENT)
 742         register struct ttyent *ty;
 743
 744         tty=0;
 745
 746         setttyent();
 747         while ((struct ttyent *)0 != (ty = getttyent())) {
 748                 tty++;
 749                 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
 750                         break;
 751         }
 752         endttyent();
 753
 754         if((struct ttyent *)0 == ty) {
 755                 log("utmp_write_entry: tty not found");
 756                 return(1);
 757         }
 758 #else /* FIXME */
 759
 760         tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
 761
 762 #endif /* HAVE_GETTTYENT */
 763
 764         if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
 765                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
 766                 /*
 767                  * Prevent luser from zero'ing out ut_host.
 768                  * If the new ut_line is empty but the old one is not
 769                  * and ut_line and ut_name match, preserve the old ut_line.
 770                  */
 771                 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
 772                         (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
 773                         (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
 774                         (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
 775                         (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
 776                 }
 777
 778                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
 779                 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
 780                         log("utmp_write_direct: error writing %s: %s",
 781                             UTMP_FILE, strerror(errno));
 782
 783                 (void)close(fd);
 784                 return 1;
 785         } else {
 786                 return 0;
 787         }
 788 }
 789 # endif /* UTMP_USE_LIBRARY */
 790
 791 static int
 792 utmp_perform_login(struct logininfo *li)
 793 {
 794         struct utmp ut;
 795
 796         construct_utmp(li, &ut);
 797 # ifdef UTMP_USE_LIBRARY
 798         if (!utmp_write_library(li, &ut)) {
 799                 log("utmp_perform_login: utmp_write_library() failed");
 800                 return 0;
 801         }
 802 # else
 803         if (!utmp_write_direct(li, &ut)) {
 804                 log("utmp_perform_login: utmp_write_direct() failed");
 805                 return 0;
 806         }
 807 # endif
 808         return 1;
 809 }
 810
 811
 812 static int
 813 utmp_perform_logout(struct logininfo *li)
 814 {
 815         struct utmp ut;
 816
 817         construct_utmp(li, &ut);
 818 # ifdef UTMP_USE_LIBRARY
 819         if (!utmp_write_library(li, &ut)) {
 820                 log("utmp_perform_logout: utmp_write_library() failed");
 821                 return 0;
 822         }
 823 # else
 824         if (!utmp_write_direct(li, &ut)) {
 825                 log("utmp_perform_logout: utmp_write_direct() failed");
 826                 return 0;
 827         }
 828 # endif
 829         return 1;
 830 }
 831
 832
 833 int
 834 utmp_write_entry(struct logininfo *li)
 835 {
 836         switch(li->type) {
 837         case LTYPE_LOGIN:
 838                 return utmp_perform_login(li);
 839
 840         case LTYPE_LOGOUT:
 841                 return utmp_perform_logout(li);
 842
 843         default:
 844                 log("utmp_write_entry: invalid type field");
 845                 return 0;
 846         }
 847 }
 848 #endif /* USE_UTMP */
 849
 850
 851 /**
 852  ** Low-level utmpx functions
 853  **/
 854
 855 /* not much point if we don't want utmpx entries */
 856 #ifdef USE_UTMPX
 857
 858 /* if we have the wherewithall, use pututxline etc. */
 859 # if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
 860         defined(HAVE_PUTUTXLINE)
 861 #  define UTMPX_USE_LIBRARY
 862 # endif
 863
 864
 865 /* write a utmpx entry with the system's help (pututxline() and pals) */
 866 # ifdef UTMPX_USE_LIBRARY
 867 static int
 868 utmpx_write_library(struct logininfo *li, struct utmpx *utx)
 869 {
 870         setutxent();
 871         pututxline(utx);
 872
 873 #  ifdef HAVE_ENDUTXENT
 874         endutxent();
 875 #  endif
 876         return 1;
 877 }
 878
 879 # else /* UTMPX_USE_LIBRARY */
 880
 881 /* write a utmp entry direct to the file */
 882 static int
 883 utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
 884 {
 885         log("utmpx_write_direct: not implemented!");
 886         return 0;
 887 }
 888 # endif /* UTMPX_USE_LIBRARY */
 889
 890 static int
 891 utmpx_perform_login(struct logininfo *li)
 892 {
 893         struct utmpx utx;
 894
 895         construct_utmpx(li, &utx);
 896 # ifdef UTMPX_USE_LIBRARY
 897         if (!utmpx_write_library(li, &utx)) {
 898                 log("utmpx_perform_login: utmp_write_library() failed");
 899                 return 0;
 900         }
 901 # else
 902         if (!utmpx_write_direct(li, &ut)) {
 903                 log("utmpx_perform_login: utmp_write_direct() failed");
 904                 return 0;
 905         }
 906 # endif
 907         return 1;
 908 }
 909
 910
 911 static int
 912 utmpx_perform_logout(struct logininfo *li)
 913 {
 914         struct utmpx utx;
 915
 916         memset(&utx, '\0', sizeof(utx));
 917         set_utmpx_time(li, &utx);
 918         line_stripname(utx.ut_line, li->line, sizeof(utx.ut_line));
 919 # ifdef HAVE_ID_IN_UTMPX
 920         line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
 921 # endif
 922 # ifdef HAVE_TYPE_IN_UTMPX
 923         utx.ut_type = DEAD_PROCESS;
 924 # endif
 925
 926 # ifdef UTMPX_USE_LIBRARY
 927         utmpx_write_library(li, &utx);
 928 # else
 929         utmpx_write_direct(li, &utx);
 930 # endif
 931         return 1;
 932 }
 933
 934 int
 935 utmpx_write_entry(struct logininfo *li)
 936 {
 937         switch(li->type) {
 938         case LTYPE_LOGIN:
 939                 return utmpx_perform_login(li);
 940         case LTYPE_LOGOUT:
 941                 return utmpx_perform_logout(li);
 942         default:
 943                 log("utmpx_write_entry: invalid type field");
 944                 return 0;
 945         }
 946 }
 947 #endif /* USE_UTMPX */
 948
 949
 950 /**
 951  ** Low-level wtmp functions
 952  **/
 953
 954 #ifdef USE_WTMP
 955
 956 /* write a wtmp entry direct to the end of the file */
 957 /* This is a slight modification of code in OpenBSD's logwtmp.c */
 958 static int
 959 wtmp_write(struct logininfo *li, struct utmp *ut)
 960 {
 961         struct stat buf;
 962         int fd, ret = 1;
 963
 964         if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
 965                 log("wtmp_write: problem writing %s: %s",
 966                     WTMP_FILE, strerror(errno));
 967                 return 0;
 968         }
 969         if (fstat(fd, &buf) == 0)
 970                 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
 971                         ftruncate(fd, buf.st_size);
 972                         log("wtmp_write: problem writing %s: %s",
 973                             WTMP_FILE, strerror(errno));
 974                         ret = 0;
 975                 }
 976         (void)close(fd);
 977         return ret;
 978 }
 979
 980 static int
 981 wtmp_perform_login(struct logininfo *li)
 982 {
 983         struct utmp ut;
 984
 985         construct_utmp(li, &ut);
 986         return wtmp_write(li, &ut);
 987 }
 988
 989
 990 static int
 991 wtmp_perform_logout(struct logininfo *li)
 992 {
 993         struct utmp ut;
 994
 995         construct_utmp(li, &ut);
 996         return wtmp_write(li, &ut);
 997 }
 998
 999
1000 int
1001 wtmp_write_entry(struct logininfo *li)
1002 {
1003         switch(li->type) {
1004         case LTYPE_LOGIN:
1005                 return wtmp_perform_login(li);
1006         case LTYPE_LOGOUT:
1007                 return wtmp_perform_logout(li);
1008         default:
1009                 log("wtmp_write_entry: invalid type field");
1010                 return 0;
1011         }
1012 }
1013
1014
1015 /* Notes on fetching login data from wtmp/wtmpx
1016  *
1017  * Logouts are usually recorded with (amongst other things) a blank
1018  * username on a given tty line.  However, some systems (HP-UX is one)
1019  * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1020  *
1021  * Since we're only looking for logins here, we know that the username
1022  * must be set correctly. On systems that leave it in, we check for
1023  * ut_type==USER_PROCESS (indicating a login.)
1024  *
1025  * Portability: Some systems may set something other than USER_PROCESS
1026  * to indicate a login process. I don't know of any as I write. Also,
1027  * it's possible that some systems may both leave the username in
1028  * place and not have ut_type.
1029  */
1030
1031 /* return true if this wtmp entry indicates a login */
1032 static int
1033 wtmp_islogin(struct logininfo *li, struct utmp *ut)
1034 {
1035         if (strncmp(li->username, ut->ut_name,
1036                 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
1037 # ifdef HAVE_TYPE_IN_UTMP
1038                 if (ut->ut_type & USER_PROCESS)
1039                         return 1;
1040 # else
1041                 return 1;
1042 # endif
1043         }
1044         return 0;
1045 }
1046
1047 int
1048 wtmp_get_entry(struct logininfo *li)
1049 {
1050         struct stat st;
1051         struct utmp ut;
1052         int fd, found=0;
1053
1054         /* Clear the time entries in our logininfo */
1055         li->tv_sec = li->tv_usec = 0;
1056
1057         if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1058                 log("wtmp_get_entry: problem opening %s: %s",
1059                     WTMP_FILE, strerror(errno));
1060                 return 0;
1061         }
1062         if (fstat(fd, &st) != 0) {
1063                 log("wtmp_get_entry: couldn't stat %s: %s",
1064                     WTMP_FILE, strerror(errno));
1065                 close(fd);
1066                 return 0;
1067         }
1068
1069         /* Seek to the start of the last struct utmp */
1070         if (lseek(fd, (off_t)(0 - sizeof(struct utmp)), SEEK_END) == -1) {
1071                 /* Looks like we've got a fresh wtmp file */
1072                 close(fd);
1073                 return 0;
1074         }
1075
1076         while (!found) {
1077                 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
1078                         log("wtmp_get_entry: read of %s failed: %s",
1079                             WTMP_FILE, strerror(errno));
1080                         close (fd);
1081                         return 0;
1082                 }
1083                 if ( wtmp_islogin(li, &ut) ) {
1084                         found = 1;
1085                         /* We've already checked for a time in struct
1086                          * utmp, in login_getlast(). */
1087 # ifdef HAVE_TIME_IN_UTMP
1088                         li->tv_sec = ut.ut_time;
1089 # else
1090 #  if HAVE_TV_IN_UTMP
1091                         li->tv_sec = ut.ut_tv.tv_sec;
1092 #  endif
1093 # endif
1094                         line_fullname(li->line, ut.ut_line,
1095                                       MIN_SIZEOF(li->line, ut.ut_line));
1096 # ifdef HAVE_HOST_IN_UTMP
1097                         strlcpy(li->hostname, ut.ut_host,
1098                                 MIN_SIZEOF(li->hostname, ut.ut_host));
1099 # endif
1100                         continue;
1101                 }
1102                 /* Seek back 2 x struct utmp */
1103                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmp)), SEEK_CUR) == -1) {
1104                         /* We've found the start of the file, so quit */
1105                         close (fd);
1106                         return 0;
1107                 }
1108         }
1109
1110         /* We found an entry. Tidy up and return */
1111         close(fd);
1112         return 1;
1113 }
1114 # endif /* USE_WTMP */
1115
1116
1117 /**
1118  ** Low-level wtmpx functions
1119  **/
1120
1121 #ifdef USE_WTMPX
1122 /* write a wtmpx entry direct to the end of the file */
1123 /* This is a slight modification of code in OpenBSD's logwtmp.c */
1124 static int
1125 wtmpx_write(struct logininfo *li, struct utmpx *utx)
1126 {
1127         struct stat buf;
1128         int fd, ret = 1;
1129
1130         if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1131                 log("wtmpx_write: problem opening %s: %s",
1132                     WTMPX_FILE, strerror(errno));
1133                 return 0;
1134         }
1135
1136         if (fstat(fd, &buf) == 0)
1137                 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
1138                         ftruncate(fd, buf.st_size);
1139                         log("wtmpx_write: problem writing %s: %s",
1140                             WTMPX_FILE, strerror(errno));
1141                         ret = 0;
1142                 }
1143         (void)close(fd);
1144
1145         return ret;
1146 }
1147
1148
1149 static int
1150 wtmpx_perform_login(struct logininfo *li)
1151 {
1152         struct utmpx utx;
1153
1154         construct_utmpx(li, &utx);
1155         return wtmpx_write(li, &utx);
1156 }
1157
1158
1159 static int
1160 wtmpx_perform_logout(struct logininfo *li)
1161 {
1162         struct utmpx utx;
1163
1164         construct_utmpx(li, &utx);
1165         return wtmpx_write(li, &utx);
1166 }
1167
1168
1169 int
1170 wtmpx_write_entry(struct logininfo *li)
1171 {
1172         switch(li->type) {
1173         case LTYPE_LOGIN:
1174                 return wtmpx_perform_login(li);
1175         case LTYPE_LOGOUT:
1176                 return wtmpx_perform_logout(li);
1177         default:
1178                 log("wtmpx_write_entry: invalid type field");
1179                 return 0;
1180         }
1181 }
1182
1183 /* Please see the notes above wtmp_islogin() for information about the
1184    next two functions */
1185
1186 /* Return true if this wtmpx entry indicates a login */
1187 static int
1188 wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1189 {
1190         if ( strncmp(li->username, utx->ut_name,
1191                 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
1192 # ifdef HAVE_TYPE_IN_UTMPX
1193                 if (utx->ut_type == USER_PROCESS)
1194                         return 1;
1195 # else
1196                 return 1;
1197 # endif
1198         }
1199         return 0;
1200 }
1201
1202
1203 int
1204 wtmpx_get_entry(struct logininfo *li)
1205 {
1206         struct stat st;
1207         struct utmpx utx;
1208         int fd, found=0;
1209
1210         /* Clear the time entries */
1211         li->tv_sec = li->tv_usec = 0;
1212
1213         if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1214                 log("wtmpx_get_entry: problem opening %s: %s",
1215                     WTMPX_FILE, strerror(errno));
1216                 return 0;
1217         }
1218         if (fstat(fd, &st) != 0) {
1219                 log("wtmpx_get_entry: couldn't stat %s: %s",
1220                     WTMP_FILE, strerror(errno));
1221                 close(fd);
1222                 return 0;
1223         }
1224
1225         /* Seek to the start of the last struct utmpx */
1226         if (lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END) == -1 ) {
1227                 /* probably a newly rotated wtmpx file */
1228                 close(fd);
1229                 return 0;
1230         }
1231
1232         while (!found) {
1233                 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
1234                         log("wtmpx_get_entry: read of %s failed: %s",
1235                             WTMPX_FILE, strerror(errno));
1236                         close (fd);
1237                         return 0;
1238                 }
1239                 /* Logouts are recorded as a blank username on a particular line.
1240                  * So, we just need to find the username in struct utmpx */
1241                 if ( wtmpx_islogin(li, &utx) ) {
1242 # ifdef HAVE_TV_IN_UTMPX
1243                         li->tv_sec = utx.ut_tv.tv_sec;
1244 # else
1245 #  ifdef HAVE_TIME_IN_UTMPX
1246                         li->tv_sec = utx.ut_time;
1247 #  endif
1248 # endif
1249                         line_fullname(li->line, utx.ut_line, sizeof(li->line));
1250 # ifdef HAVE_HOST_IN_UTMPX
1251                         strlcpy(li->hostname, utx.ut_host,
1252                                 MIN_SIZEOF(li->hostname, utx.ut_host));
1253 # endif
1254                         continue;
1255                 }
1256                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmpx)), SEEK_CUR) == -1) {
1257                         close (fd);
1258                         return 0;
1259                 }
1260         }
1261
1262         close(fd);
1263         return 1;
1264 }
1265 #endif /* USE_WTMPX */
1266
1267 /**
1268  ** Low-level libutil login() functions
1269  **/
1270
1271 #ifdef USE_LOGIN
1272 static int
1273 syslogin_perform_login(struct logininfo *li)
1274 {
1275         struct utmp *ut;
1276
1277         if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
1278                 log("syslogin_perform_login: couldn't malloc()");
1279                 return 0;
1280         }
1281         construct_utmp(li, ut);
1282         login(ut);
1283
1284         return 1;
1285 }
1286
1287 static int
1288 syslogin_perform_logout(struct logininfo *li)
1289 {
1290 # ifdef HAVE_LOGOUT
1291         char line[8];
1292
1293         (void)line_stripname(line, li->line, sizeof(line));
1294
1295         if (!logout(line)) {
1296                 log("syslogin_perform_logout: logout() returned an error");
1297 #  ifdef HAVE_LOGWTMP
1298         } else {
1299                 logwtmp(line, "", "");
1300 #  endif
1301         }
1302         /* FIXME: (ATL - if the need arises) What to do if we have
1303          * login, but no logout?  what if logout but no logwtmp? All
1304          * routines are in libutil so they should all be there,
1305          * but... */
1306 # endif
1307         return 1;
1308 }
1309
1310 int
1311 syslogin_write_entry(struct logininfo *li)
1312 {
1313         switch (li->type) {
1314         case LTYPE_LOGIN:
1315                 return syslogin_perform_login(li);
1316         case LTYPE_LOGOUT:
1317                 return syslogin_perform_logout(li);
1318         default:
1319                 log("syslogin_write_entry: Invalid type field");
1320                 return 0;
1321         }
1322 }
1323 #endif /* USE_LOGIN */
1324
1325 /* end of file log-syslogin.c */
1326
1327 /**
1328  ** Low-level lastlog functions
1329  **/
1330
1331 #ifdef USE_LASTLOG
1332 #define LL_FILE 1
1333 #define LL_DIR 2
1334 #define LL_OTHER 3
1335
1336 static void
1337 lastlog_construct(struct logininfo *li, struct lastlog *last)
1338 {
1339         /* clear the structure */
1340         memset(last, '\0', sizeof(*last));
1341
1342         (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
1343         strlcpy(last->ll_host, li->hostname,
1344                 MIN_SIZEOF(last->ll_host, li->hostname));
1345         last->ll_time = li->tv_sec;
1346 }
1347
1348 static int
1349 lastlog_filetype(char *filename)
1350 {
1351         struct stat st;
1352
1353         if (stat(LASTLOG_FILE, &st) != 0) {
1354                 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
1355                         strerror(errno));
1356                 return 0;
1357         }
1358         if (S_ISDIR(st.st_mode))
1359                 return LL_DIR;
1360         else if (S_ISREG(st.st_mode))
1361                 return LL_FILE;
1362         else
1363                 return LL_OTHER;
1364 }
1365
1366
1367 /* open the file (using filemode) and seek to the login entry */
1368 static int
1369 lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1370 {
1371         off_t offset;
1372         int type;
1373         char lastlog_file[1024];
1374
1375         type = lastlog_filetype(LASTLOG_FILE);
1376         switch (type) {
1377                 case LL_FILE:
1378                         strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1379                         break;
1380                 case LL_DIR:
1381                         snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1382                                  LASTLOG_FILE, li->username);
1383                         break;
1384                 default:
1385                         log("lastlog_openseek: %.100s is not a file or directory!",
1386                             LASTLOG_FILE);
1387                         return 0;
1388         }
1389
1390         *fd = open(lastlog_file, filemode);
1391         if ( *fd < 0) {
1392                 debug("lastlog_openseek: Couldn't open %s: %s",
1393                     lastlog_file, strerror(errno));
1394                 return 0;
1395         }
1396
1397         if (type == LL_FILE) {
1398                 /* find this uid's offset in the lastlog file */
1399                 offset = (off_t) ( (long)li->uid * sizeof(struct lastlog));
1400
1401                 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1402                         log("lastlog_openseek: %s->lseek(): %s",
1403                          lastlog_file, strerror(errno));
1404                         return 0;
1405                 }
1406         }
1407
1408         return 1;
1409 }
1410
1411 static int
1412 lastlog_perform_login(struct logininfo *li)
1413 {
1414         struct lastlog last;
1415         int fd;
1416
1417         /* create our struct lastlog */
1418         lastlog_construct(li, &last);
1419
1420         if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1421                 return(0);
1422
1423         /* write the entry */
1424         if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1425                 close(fd);
1426                 log("lastlog_write_filemode: Error writing to %s: %s",
1427                     LASTLOG_FILE, strerror(errno));
1428                 return 0;
1429         }
1430
1431         close(fd);
1432         return 1;
1433 }
1434
1435 int
1436 lastlog_write_entry(struct logininfo *li)
1437 {
1438         switch(li->type) {
1439         case LTYPE_LOGIN:
1440                 return lastlog_perform_login(li);
1441         default:
1442                 log("lastlog_write_entry: Invalid type field");
1443                 return 0;
1444         }
1445 }
1446
1447 static void
1448 lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1449 {
1450         line_fullname(li->line, last->ll_line, sizeof(li->line));
1451         strlcpy(li->hostname, last->ll_host,
1452                 MIN_SIZEOF(li->hostname, last->ll_host));
1453         li->tv_sec = last->ll_time;
1454 }
1455
1456 int
1457 lastlog_get_entry(struct logininfo *li)
1458 {
1459         struct lastlog last;
1460         int fd;
1461
1462         if (lastlog_openseek(li, &fd, O_RDONLY)) {
1463                 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1464                         log("lastlog_get_entry: Error reading from %s: %s",
1465                             LASTLOG_FILE, strerror(errno));
1466                         return 0;
1467                 } else {
1468                         lastlog_populate_entry(li, &last);
1469                         return 1;
1470                 }
1471         } else {
1472                 return 0;
1473         }
1474 }
1475 #endif /* USE_LASTLOG */