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