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