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