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