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