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