loginrec.c

   1 /*
   2  * Copyright (c) 2000 Andre Lucas.  All rights reserved.
   3  * Portions copyright (c) 1998 Todd C. Miller
   4  * Portions copyright (c) 1996 Jason Downs
   5  * Portions copyright (c) 1996 Theo de Raadt
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by Markus Friedl.
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /**
  34  ** loginrec.c:  platform-independent login recording and lastlog retrieval
  35  **/
  36
  37 /*
  38   The new login code explained
  39   ============================
  40
  41   This code attempts to provide a common interface to login recording
  42   (utmp and friends) and last login time retrieval.
  43
  44   Its primary means of achieving this is to use 'struct logininfo', a
  45   union of all the useful fields in the various different types of
  46   system login record structures one finds on UNIX variants.
  47
  48   We depend on autoconf to define which recording methods are to be
  49   used, and which fields are contained in the relevant data structures
  50   on the local system. Many C preprocessor symbols affect which code
  51   gets compiled here.
  52
  53   The code is designed to make it easy to modify a particular
  54   recording method, without affecting other methods nor requiring so
  55   many nested conditional compilation blocks as were commonplace in
  56   the old code.
  57
  58   For login recording, we try to use the local system's libraries as
  59   these are clearly most likely to work correctly. For utmp systems
  60   this usually means login() and logout() or setutent() etc., probably
  61   in libutil, along with logwtmp() etc. On these systems, we fall back
  62   to writing the files directly if we have to, though this method
  63   requires very thorough testing so we do not corrupt local auditing
  64   information. These files and their access methods are very system
  65   specific indeed.
  66
  67   For utmpx systems, the corresponding library functions are
  68   setutxent() etc. To the author's knowledge, all utmpx systems have
  69   these library functions and so no direct write is attempted. If such
  70   a system exists and needs support, direct analogues of the [uw]tmp
  71   code should suffice.
  72
  73   Retrieving the time of last login ('lastlog') is in some ways even
  74   more problemmatic than login recording. Some systems provide a
  75   simple table of all users which we seek based on uid and retrieve a
  76   relatively standard structure. Others record the same information in
  77   a directory with a separate file, and others don't record the
  78   information separately at all. For systems in the latter category,
  79   we look backwards in the wtmp or wtmpx file for the last login entry
  80   for our user. Naturally this is slower and on busy systems could
  81   incur a significant performance penalty.
  82
  83   Calling the new code
  84   --------------------
  85
  86   In OpenSSH all login recording and retrieval is performed in
  87   login.c. Here you'll find working examples. Also, in the logintest.c
  88   program there are more examples.
  89
  90   Internal handler calling method
  91   -------------------------------
  92
  93   When a call is made to login_login() or login_logout(), both
  94   routines set a struct logininfo flag defining which action (log in,
  95   or log out) is to be taken. They both then call login_write(), which
  96   calls whichever of the many structure-specific handlers autoconf
  97   selects for the local system.
  98
  99   The handlers themselves handle system data structure specifics. Both
 100   struct utmp and struct utmpx have utility functions (see
 101   construct_utmp*()) to try to make it simpler to add extra systems
 102   that introduce new features to either structure.
 103
 104   While it may seem terribly wasteful to replicate so much similar
 105   code for each method, experience has shown that maintaining code to
 106   write both struct utmp and utmpx in one function, whilst maintaining
 107   support for all systems whether they have library support or not, is
 108   a difficult and time-consuming task.
 109
 110   Lastlog support proceeds similarly. Functions login_get_lastlog()
 111   (and its OpenSSH-tuned friend login_get_lastlog_time()) call
 112   getlast_entry(), which tries one of three methods to find the last
 113   login time. It uses local system lastlog support if it can,
 114   otherwise it tries wtmp or wtmpx before giving up and returning 0,
 115   meaning "tilt".
 116
 117   Maintenance
 118   -----------
 119
 120   In many cases it's possible to tweak autoconf to select the correct
 121   methods for a particular platform, either by improving the detection
 122   code (best), or by presetting DISABLE_<method> or CONF_<method>_FILE
 123   symbols for the platform.
 124
 125   Use logintest to check which symbols are defined before modifying
 126   configure.in and loginrec.c. (You have to build logintest yourself
 127   with 'make logintest' as it's not built by default.)
 128
 129   Otherwise, patches to the specific method(s) are very helpful!
 130
 131 */
 132
 133 /**
 134  ** TODO:
 135  **   homegrown ttyslot()
 136  **   test, test, test
 137  **
 138  ** Platform status:
 139  ** ----------------
 140  **
 141  ** Known good:
 142  **   Linux (Redhat 6.2, Debian)
 143  **   Solaris
 144  **   HP-UX 10.20 (gcc only)
 145  **   IRIX
 146  **   NeXT - M68k/HPPA/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 # ifdef USE_UTMP
 452         utmp_write_entry(li);
 453 # endif
 454 # ifdef USE_WTMP
 455         wtmp_write_entry(li);
 456 # endif
 457 # ifdef USE_UTMPX
 458         utmpx_write_entry(li);
 459 # endif
 460 # ifdef USE_WTMPX
 461         wtmpx_write_entry(li);
 462 # endif
 463         return 0;
 464 }
 465 #endif
 466
 467 /**
 468  ** getlast_entry: Call low-level functions to retrieve the last login
 469  **                time.
 470  **/
 471
 472 /* take the uid in li and return the last login time */
 473 int
 474 getlast_entry(struct logininfo *li)
 475 {
 476 #ifdef USE_LASTLOG
 477         return(lastlog_get_entry(li));
 478 #else /* !USE_LASTLOG */
 479
 480 #ifdef DISABLE_LASTLOG
 481         /* On some systems we shouldn't even try to obtain last login
 482          * time, e.g. AIX */
 483         return 0;
 484 # else /* DISABLE_LASTLOG */
 485         /* Try to retrieve the last login time from wtmp */
 486 #  if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
 487         /* retrieve last login time from utmp */
 488         return (wtmp_get_entry(li));
 489 #  else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
 490         /* If wtmp isn't available, try wtmpx */
 491 #   if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
 492         /* retrieve last login time from utmpx */
 493         return (wtmpx_get_entry(li));
 494 #   else
 495         /* Give up: No means of retrieving last login time */
 496         return 0;
 497 #   endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
 498 #  endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
 499 # endif /* DISABLE_LASTLOG */
 500 #endif /* USE_LASTLOG */
 501 }
 502
 503
 504
 505 /*
 506  * 'line' string utility functions
 507  *
 508  * These functions process the 'line' string into one of three forms:
 509  *
 510  * 1. The full filename (including '/dev')
 511  * 2. The stripped name (excluding '/dev')
 512  * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
 513  *                               /dev/pts/1  -> ts/1 )
 514  *
 515  * Form 3 is used on some systems to identify a .tmp.? entry when
 516  * attempting to remove it. Typically both addition and removal is
 517  * performed by one application - say, sshd - so as long as the choice
 518  * uniquely identifies a terminal it's ok.
 519  */
 520
 521
 522 /* line_fullname(): add the leading '/dev/' if it doesn't exist make
 523  * sure dst has enough space, if not just copy src (ugh) */
 524 char *
 525 line_fullname(char *dst, const char *src, int dstsize)
 526 {
 527         memset(dst, '\0', dstsize);
 528         if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
 529                 strlcpy(dst, src, dstsize);
 530         } else {
 531                 strlcpy(dst, "/dev/", dstsize);
 532                 strlcat(dst, src, dstsize);
 533         }
 534         return dst;
 535 }
 536
 537 /* line_stripname(): strip the leading '/dev' if it exists, return dst */
 538 char *
 539 line_stripname(char *dst, const char *src, int dstsize)
 540 {
 541         memset(dst, '\0', dstsize);
 542         if (strncmp(src, "/dev/", 5) == 0)
 543                 strlcpy(dst, src + 5, dstsize);
 544         else
 545                 strlcpy(dst, src, dstsize);
 546         return dst;
 547 }
 548
 549 /* line_abbrevname(): Return the abbreviated (usually four-character)
 550  * form of the line (Just use the last <dstsize> characters of the
 551  * full name.)
 552  *
 553  * NOTE: use strncpy because we do NOT necessarily want zero
 554  * termination */
 555 char *
 556 line_abbrevname(char *dst, const char *src, int dstsize)
 557 {
 558         size_t len;
 559
 560         memset(dst, '\0', dstsize);
 561
 562         /* Always skip prefix if present */
 563         if (strncmp(src, "/dev/", 5) == 0)
 564                 src += 5;
 565
 566         len = strlen(src);
 567
 568         if (len > 0) {
 569                 if (((int)len - dstsize) > 0)
 570                         src +=  ((int)len - dstsize);
 571
 572                 /* note: _don't_ change this to strlcpy */
 573                 strncpy(dst, src, (size_t)dstsize);
 574         }
 575
 576         return dst;
 577 }
 578
 579 /**
 580  ** utmp utility functions
 581  **
 582  ** These functions manipulate struct utmp, taking system differences
 583  ** into account.
 584  **/
 585
 586 #if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
 587
 588 /* build the utmp structure */
 589 void
 590 set_utmp_time(struct logininfo *li, struct utmp *ut)
 591 {
 592 # ifdef HAVE_TV_IN_UTMP
 593         ut->ut_tv.tv_sec = li->tv_sec;
 594         ut->ut_tv.tv_usec = li->tv_usec;
 595 # else
 596 #  ifdef HAVE_TIME_IN_UTMP
 597         ut->ut_time = li->tv_sec;
 598 #  endif
 599 # endif
 600 }
 601
 602 void
 603 construct_utmp(struct logininfo *li,
 604                     struct utmp *ut)
 605 {
 606         memset(ut, '\0', sizeof(*ut));
 607
 608         /* First fill out fields used for both logins and logouts */
 609
 610 # ifdef HAVE_ID_IN_UTMP
 611         line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
 612 # endif
 613
 614 # ifdef HAVE_TYPE_IN_UTMP
 615         /* This is done here to keep utmp constants out of struct logininfo */
 616         switch (li->type) {
 617         case LTYPE_LOGIN:
 618                 ut->ut_type = USER_PROCESS;
 619 #ifdef _CRAY
 620                 cray_set_tmpdir(ut);
 621 #endif
 622                 break;
 623         case LTYPE_LOGOUT:
 624                 ut->ut_type = DEAD_PROCESS;
 625 #ifdef _CRAY
 626                 cray_retain_utmp(ut, li->pid);
 627 #endif
 628                 break;
 629         }
 630 # endif
 631         set_utmp_time(li, ut);
 632
 633         line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
 634
 635 # ifdef HAVE_PID_IN_UTMP
 636         ut->ut_pid = li->pid;
 637 # endif
 638
 639         /* If we're logging out, leave all other fields blank */
 640         if (li->type == LTYPE_LOGOUT)
 641           return;
 642
 643         /*
 644          * These fields are only used when logging in, and are blank
 645          * for logouts.
 646          */
 647
 648         /* Use strncpy because we don't necessarily want null termination */
 649         strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
 650 # ifdef HAVE_HOST_IN_UTMP
 651         strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
 652 # endif
 653 # ifdef HAVE_ADDR_IN_UTMP
 654         /* this is just a 32-bit IP address */
 655         if (li->hostaddr.sa.sa_family == AF_INET)
 656                 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
 657 # endif
 658 }
 659 #endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
 660
 661 /**
 662  ** utmpx utility functions
 663  **
 664  ** These functions manipulate struct utmpx, accounting for system
 665  ** variations.
 666  **/
 667
 668 #if defined(USE_UTMPX) || defined (USE_WTMPX)
 669 /* build the utmpx structure */
 670 void
 671 set_utmpx_time(struct logininfo *li, struct utmpx *utx)
 672 {
 673 # ifdef HAVE_TV_IN_UTMPX
 674         utx->ut_tv.tv_sec = li->tv_sec;
 675         utx->ut_tv.tv_usec = li->tv_usec;
 676 # else /* HAVE_TV_IN_UTMPX */
 677 #  ifdef HAVE_TIME_IN_UTMPX
 678         utx->ut_time = li->tv_sec;
 679 #  endif /* HAVE_TIME_IN_UTMPX */
 680 # endif /* HAVE_TV_IN_UTMPX */
 681 }
 682
 683 void
 684 construct_utmpx(struct logininfo *li, struct utmpx *utx)
 685 {
 686         memset(utx, '\0', sizeof(*utx));
 687 # ifdef HAVE_ID_IN_UTMPX
 688         line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
 689 # endif
 690
 691         /* this is done here to keep utmp constants out of loginrec.h */
 692         switch (li->type) {
 693         case LTYPE_LOGIN:
 694                 utx->ut_type = USER_PROCESS;
 695                 break;
 696         case LTYPE_LOGOUT:
 697                 utx->ut_type = DEAD_PROCESS;
 698                 break;
 699         }
 700         line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
 701         set_utmpx_time(li, utx);
 702         utx->ut_pid = li->pid;
 703
 704         if (li->type == LTYPE_LOGOUT)
 705                 return;
 706
 707         /*
 708          * These fields are only used when logging in, and are blank
 709          * for logouts.
 710          */
 711
 712         /* strncpy(): Don't necessarily want null termination */
 713         strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
 714 # ifdef HAVE_HOST_IN_UTMPX
 715         strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
 716 # endif
 717 # ifdef HAVE_ADDR_IN_UTMPX
 718         /* this is just a 32-bit IP address */
 719         if (li->hostaddr.sa.sa_family == AF_INET)
 720                 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
 721 # endif
 722 # ifdef HAVE_SYSLEN_IN_UTMPX
 723         /* ut_syslen is the length of the utx_host string */
 724         utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
 725 # endif
 726 }
 727 #endif /* USE_UTMPX || USE_WTMPX */
 728
 729 /**
 730  ** Low-level utmp functions
 731  **/
 732
 733 /* FIXME: (ATL) utmp_write_direct needs testing */
 734 #ifdef USE_UTMP
 735
 736 /* if we can, use pututline() etc. */
 737 # if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
 738         defined(HAVE_PUTUTLINE)
 739 #  define UTMP_USE_LIBRARY
 740 # endif
 741
 742
 743 /* write a utmp entry with the system's help (pututline() and pals) */
 744 # ifdef UTMP_USE_LIBRARY
 745 static int
 746 utmp_write_library(struct logininfo *li, struct utmp *ut)
 747 {
 748         setutent();
 749         pututline(ut);
 750
 751 #  ifdef HAVE_ENDUTENT
 752         endutent();
 753 #  endif
 754         return 1;
 755 }
 756 # else /* UTMP_USE_LIBRARY */
 757
 758 /* write a utmp entry direct to the file */
 759 /* This is a slightly modification of code in OpenBSD's login.c */
 760 static int
 761 utmp_write_direct(struct logininfo *li, struct utmp *ut)
 762 {
 763         struct utmp old_ut;
 764         register int fd;
 765         int tty;
 766
 767         /* FIXME: (ATL) ttyslot() needs local implementation */
 768
 769 #if defined(HAVE_GETTTYENT)
 770         register struct ttyent *ty;
 771
 772         tty=0;
 773
 774         setttyent();
 775         while ((struct ttyent *)0 != (ty = getttyent())) {
 776                 tty++;
 777                 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
 778                         break;
 779         }
 780         endttyent();
 781
 782         if((struct ttyent *)0 == ty) {
 783                 log("utmp_write_entry: tty not found");
 784                 return(1);
 785         }
 786 #else /* FIXME */
 787
 788         tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
 789
 790 #endif /* HAVE_GETTTYENT */
 791
 792         if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
 793                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
 794                 /*
 795                  * Prevent luser from zero'ing out ut_host.
 796                  * If the new ut_line is empty but the old one is not
 797                  * and ut_line and ut_name match, preserve the old ut_line.
 798                  */
 799                 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
 800                         (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
 801                         (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
 802                         (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
 803                         (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
 804                 }
 805
 806                 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
 807                 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
 808                         log("utmp_write_direct: error writing %s: %s",
 809                             UTMP_FILE, strerror(errno));
 810
 811                 (void)close(fd);
 812                 return 1;
 813         } else {
 814                 return 0;
 815         }
 816 }
 817 # endif /* UTMP_USE_LIBRARY */
 818
 819 static int
 820 utmp_perform_login(struct logininfo *li)
 821 {
 822         struct utmp ut;
 823
 824         construct_utmp(li, &ut);
 825 # ifdef UTMP_USE_LIBRARY
 826         if (!utmp_write_library(li, &ut)) {
 827                 log("utmp_perform_login: utmp_write_library() failed");
 828                 return 0;
 829         }
 830 # else
 831         if (!utmp_write_direct(li, &ut)) {
 832                 log("utmp_perform_login: utmp_write_direct() failed");
 833                 return 0;
 834         }
 835 # endif
 836         return 1;
 837 }
 838
 839
 840 static int
 841 utmp_perform_logout(struct logininfo *li)
 842 {
 843         struct utmp ut;
 844
 845         construct_utmp(li, &ut);
 846 # ifdef UTMP_USE_LIBRARY
 847         if (!utmp_write_library(li, &ut)) {
 848                 log("utmp_perform_logout: utmp_write_library() failed");
 849                 return 0;
 850         }
 851 # else
 852         if (!utmp_write_direct(li, &ut)) {
 853                 log("utmp_perform_logout: utmp_write_direct() failed");
 854                 return 0;
 855         }
 856 # endif
 857         return 1;
 858 }
 859
 860
 861 int
 862 utmp_write_entry(struct logininfo *li)
 863 {
 864         switch(li->type) {
 865         case LTYPE_LOGIN:
 866                 return utmp_perform_login(li);
 867
 868         case LTYPE_LOGOUT:
 869                 return utmp_perform_logout(li);
 870
 871         default:
 872                 log("utmp_write_entry: invalid type field");
 873                 return 0;
 874         }
 875 }
 876 #endif /* USE_UTMP */
 877
 878
 879 /**
 880  ** Low-level utmpx functions
 881  **/
 882
 883 /* not much point if we don't want utmpx entries */
 884 #ifdef USE_UTMPX
 885
 886 /* if we have the wherewithall, use pututxline etc. */
 887 # if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
 888         defined(HAVE_PUTUTXLINE)
 889 #  define UTMPX_USE_LIBRARY
 890 # endif
 891
 892
 893 /* write a utmpx entry with the system's help (pututxline() and pals) */
 894 # ifdef UTMPX_USE_LIBRARY
 895 static int
 896 utmpx_write_library(struct logininfo *li, struct utmpx *utx)
 897 {
 898         setutxent();
 899         pututxline(utx);
 900
 901 #  ifdef HAVE_ENDUTXENT
 902         endutxent();
 903 #  endif
 904         return 1;
 905 }
 906
 907 # else /* UTMPX_USE_LIBRARY */
 908
 909 /* write a utmp entry direct to the file */
 910 static int
 911 utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
 912 {
 913         log("utmpx_write_direct: not implemented!");
 914         return 0;
 915 }
 916 # endif /* UTMPX_USE_LIBRARY */
 917
 918 static int
 919 utmpx_perform_login(struct logininfo *li)
 920 {
 921         struct utmpx utx;
 922
 923         construct_utmpx(li, &utx);
 924 # ifdef UTMPX_USE_LIBRARY
 925         if (!utmpx_write_library(li, &utx)) {
 926                 log("utmpx_perform_login: utmp_write_library() failed");
 927                 return 0;
 928         }
 929 # else
 930         if (!utmpx_write_direct(li, &ut)) {
 931                 log("utmpx_perform_login: utmp_write_direct() failed");
 932                 return 0;
 933         }
 934 # endif
 935         return 1;
 936 }
 937
 938
 939 static int
 940 utmpx_perform_logout(struct logininfo *li)
 941 {
 942         struct utmpx utx;
 943
 944         memset(&utx, '\0', sizeof(utx));
 945         set_utmpx_time(li, &utx);
 946         line_stripname(utx.ut_line, li->line, sizeof(utx.ut_line));
 947 # ifdef HAVE_ID_IN_UTMPX
 948         line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
 949 # endif
 950 # ifdef HAVE_TYPE_IN_UTMPX
 951         utx.ut_type = DEAD_PROCESS;
 952 # endif
 953
 954 # ifdef UTMPX_USE_LIBRARY
 955         utmpx_write_library(li, &utx);
 956 # else
 957         utmpx_write_direct(li, &utx);
 958 # endif
 959         return 1;
 960 }
 961
 962 int
 963 utmpx_write_entry(struct logininfo *li)
 964 {
 965         switch(li->type) {
 966         case LTYPE_LOGIN:
 967                 return utmpx_perform_login(li);
 968         case LTYPE_LOGOUT:
 969                 return utmpx_perform_logout(li);
 970         default:
 971                 log("utmpx_write_entry: invalid type field");
 972                 return 0;
 973         }
 974 }
 975 #endif /* USE_UTMPX */
 976
 977
 978 /**
 979  ** Low-level wtmp functions
 980  **/
 981
 982 #ifdef USE_WTMP
 983
 984 /* write a wtmp entry direct to the end of the file */
 985 /* This is a slight modification of code in OpenBSD's logwtmp.c */
 986 static int
 987 wtmp_write(struct logininfo *li, struct utmp *ut)
 988 {
 989         struct stat buf;
 990         int fd, ret = 1;
 991
 992         if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
 993                 log("wtmp_write: problem writing %s: %s",
 994                     WTMP_FILE, strerror(errno));
 995                 return 0;
 996         }
 997         if (fstat(fd, &buf) == 0)
 998                 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
 999                         ftruncate(fd, buf.st_size);
1000                         log("wtmp_write: problem writing %s: %s",
1001                             WTMP_FILE, strerror(errno));
1002                         ret = 0;
1003                 }
1004         (void)close(fd);
1005         return ret;
1006 }
1007
1008 static int
1009 wtmp_perform_login(struct logininfo *li)
1010 {
1011         struct utmp ut;
1012
1013         construct_utmp(li, &ut);
1014         return wtmp_write(li, &ut);
1015 }
1016
1017
1018 static int
1019 wtmp_perform_logout(struct logininfo *li)
1020 {
1021         struct utmp ut;
1022
1023         construct_utmp(li, &ut);
1024         return wtmp_write(li, &ut);
1025 }
1026
1027
1028 int
1029 wtmp_write_entry(struct logininfo *li)
1030 {
1031         switch(li->type) {
1032         case LTYPE_LOGIN:
1033                 return wtmp_perform_login(li);
1034         case LTYPE_LOGOUT:
1035                 return wtmp_perform_logout(li);
1036         default:
1037                 log("wtmp_write_entry: invalid type field");
1038                 return 0;
1039         }
1040 }
1041
1042
1043 /* Notes on fetching login data from wtmp/wtmpx
1044  *
1045  * Logouts are usually recorded with (amongst other things) a blank
1046  * username on a given tty line.  However, some systems (HP-UX is one)
1047  * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1048  *
1049  * Since we're only looking for logins here, we know that the username
1050  * must be set correctly. On systems that leave it in, we check for
1051  * ut_type==USER_PROCESS (indicating a login.)
1052  *
1053  * Portability: Some systems may set something other than USER_PROCESS
1054  * to indicate a login process. I don't know of any as I write. Also,
1055  * it's possible that some systems may both leave the username in
1056  * place and not have ut_type.
1057  */
1058
1059 /* return true if this wtmp entry indicates a login */
1060 static int
1061 wtmp_islogin(struct logininfo *li, struct utmp *ut)
1062 {
1063         if (strncmp(li->username, ut->ut_name,
1064                 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
1065 # ifdef HAVE_TYPE_IN_UTMP
1066                 if (ut->ut_type & USER_PROCESS)
1067                         return 1;
1068 # else
1069                 return 1;
1070 # endif
1071         }
1072         return 0;
1073 }
1074
1075 int
1076 wtmp_get_entry(struct logininfo *li)
1077 {
1078         struct stat st;
1079         struct utmp ut;
1080         int fd, found=0;
1081
1082         /* Clear the time entries in our logininfo */
1083         li->tv_sec = li->tv_usec = 0;
1084
1085         if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1086                 log("wtmp_get_entry: problem opening %s: %s",
1087                     WTMP_FILE, strerror(errno));
1088                 return 0;
1089         }
1090         if (fstat(fd, &st) != 0) {
1091                 log("wtmp_get_entry: couldn't stat %s: %s",
1092                     WTMP_FILE, strerror(errno));
1093                 close(fd);
1094                 return 0;
1095         }
1096
1097         /* Seek to the start of the last struct utmp */
1098         if (lseek(fd, (off_t)(0 - sizeof(struct utmp)), SEEK_END) == -1) {
1099                 /* Looks like we've got a fresh wtmp file */
1100                 close(fd);
1101                 return 0;
1102         }
1103
1104         while (!found) {
1105                 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
1106                         log("wtmp_get_entry: read of %s failed: %s",
1107                             WTMP_FILE, strerror(errno));
1108                         close (fd);
1109                         return 0;
1110                 }
1111                 if ( wtmp_islogin(li, &ut) ) {
1112                         found = 1;
1113                         /* We've already checked for a time in struct
1114                          * utmp, in login_getlast(). */
1115 # ifdef HAVE_TIME_IN_UTMP
1116                         li->tv_sec = ut.ut_time;
1117 # else
1118 #  if HAVE_TV_IN_UTMP
1119                         li->tv_sec = ut.ut_tv.tv_sec;
1120 #  endif
1121 # endif
1122                         line_fullname(li->line, ut.ut_line,
1123                                       MIN_SIZEOF(li->line, ut.ut_line));
1124 # ifdef HAVE_HOST_IN_UTMP
1125                         strlcpy(li->hostname, ut.ut_host,
1126                                 MIN_SIZEOF(li->hostname, ut.ut_host));
1127 # endif
1128                         continue;
1129                 }
1130                 /* Seek back 2 x struct utmp */
1131                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmp)), SEEK_CUR) == -1) {
1132                         /* We've found the start of the file, so quit */
1133                         close (fd);
1134                         return 0;
1135                 }
1136         }
1137
1138         /* We found an entry. Tidy up and return */
1139         close(fd);
1140         return 1;
1141 }
1142 # endif /* USE_WTMP */
1143
1144
1145 /**
1146  ** Low-level wtmpx functions
1147  **/
1148
1149 #ifdef USE_WTMPX
1150 /* write a wtmpx entry direct to the end of the file */
1151 /* This is a slight modification of code in OpenBSD's logwtmp.c */
1152 static int
1153 wtmpx_write(struct logininfo *li, struct utmpx *utx)
1154 {
1155         struct stat buf;
1156         int fd, ret = 1;
1157
1158         if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1159                 log("wtmpx_write: problem opening %s: %s",
1160                     WTMPX_FILE, strerror(errno));
1161                 return 0;
1162         }
1163
1164         if (fstat(fd, &buf) == 0)
1165                 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
1166                         ftruncate(fd, buf.st_size);
1167                         log("wtmpx_write: problem writing %s: %s",
1168                             WTMPX_FILE, strerror(errno));
1169                         ret = 0;
1170                 }
1171         (void)close(fd);
1172
1173         return ret;
1174 }
1175
1176
1177 static int
1178 wtmpx_perform_login(struct logininfo *li)
1179 {
1180         struct utmpx utx;
1181
1182         construct_utmpx(li, &utx);
1183         return wtmpx_write(li, &utx);
1184 }
1185
1186
1187 static int
1188 wtmpx_perform_logout(struct logininfo *li)
1189 {
1190         struct utmpx utx;
1191
1192         construct_utmpx(li, &utx);
1193         return wtmpx_write(li, &utx);
1194 }
1195
1196
1197 int
1198 wtmpx_write_entry(struct logininfo *li)
1199 {
1200         switch(li->type) {
1201         case LTYPE_LOGIN:
1202                 return wtmpx_perform_login(li);
1203         case LTYPE_LOGOUT:
1204                 return wtmpx_perform_logout(li);
1205         default:
1206                 log("wtmpx_write_entry: invalid type field");
1207                 return 0;
1208         }
1209 }
1210
1211 /* Please see the notes above wtmp_islogin() for information about the
1212    next two functions */
1213
1214 /* Return true if this wtmpx entry indicates a login */
1215 static int
1216 wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1217 {
1218         if ( strncmp(li->username, utx->ut_name,
1219                 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
1220 # ifdef HAVE_TYPE_IN_UTMPX
1221                 if (utx->ut_type == USER_PROCESS)
1222                         return 1;
1223 # else
1224                 return 1;
1225 # endif
1226         }
1227         return 0;
1228 }
1229
1230
1231 int
1232 wtmpx_get_entry(struct logininfo *li)
1233 {
1234         struct stat st;
1235         struct utmpx utx;
1236         int fd, found=0;
1237
1238         /* Clear the time entries */
1239         li->tv_sec = li->tv_usec = 0;
1240
1241         if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1242                 log("wtmpx_get_entry: problem opening %s: %s",
1243                     WTMPX_FILE, strerror(errno));
1244                 return 0;
1245         }
1246         if (fstat(fd, &st) != 0) {
1247                 log("wtmpx_get_entry: couldn't stat %s: %s",
1248                     WTMP_FILE, strerror(errno));
1249                 close(fd);
1250                 return 0;
1251         }
1252
1253         /* Seek to the start of the last struct utmpx */
1254         if (lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END) == -1 ) {
1255                 /* probably a newly rotated wtmpx file */
1256                 close(fd);
1257                 return 0;
1258         }
1259
1260         while (!found) {
1261                 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
1262                         log("wtmpx_get_entry: read of %s failed: %s",
1263                             WTMPX_FILE, strerror(errno));
1264                         close (fd);
1265                         return 0;
1266                 }
1267                 /* Logouts are recorded as a blank username on a particular line.
1268                  * So, we just need to find the username in struct utmpx */
1269                 if ( wtmpx_islogin(li, &utx) ) {
1270 # ifdef HAVE_TV_IN_UTMPX
1271                         li->tv_sec = utx.ut_tv.tv_sec;
1272 # else
1273 #  ifdef HAVE_TIME_IN_UTMPX
1274                         li->tv_sec = utx.ut_time;
1275 #  endif
1276 # endif
1277                         line_fullname(li->line, utx.ut_line, sizeof(li->line));
1278 # ifdef HAVE_HOST_IN_UTMPX
1279                         strlcpy(li->hostname, utx.ut_host,
1280                                 MIN_SIZEOF(li->hostname, utx.ut_host));
1281 # endif
1282                         continue;
1283                 }
1284                 if (lseek(fd, (off_t)(0-2*sizeof(struct utmpx)), SEEK_CUR) == -1) {
1285                         close (fd);
1286                         return 0;
1287                 }
1288         }
1289
1290         close(fd);
1291         return 1;
1292 }
1293 #endif /* USE_WTMPX */
1294
1295 /**
1296  ** Low-level libutil login() functions
1297  **/
1298
1299 #ifdef USE_LOGIN
1300 static int
1301 syslogin_perform_login(struct logininfo *li)
1302 {
1303         struct utmp *ut;
1304
1305         if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
1306                 log("syslogin_perform_login: couldn't malloc()");
1307                 return 0;
1308         }
1309         construct_utmp(li, ut);
1310         login(ut);
1311
1312         return 1;
1313 }
1314
1315 static int
1316 syslogin_perform_logout(struct logininfo *li)
1317 {
1318 # ifdef HAVE_LOGOUT
1319         char line[8];
1320
1321         (void)line_stripname(line, li->line, sizeof(line));
1322
1323         if (!logout(line)) {
1324                 log("syslogin_perform_logout: logout() returned an error");
1325 #  ifdef HAVE_LOGWTMP
1326         } else {
1327                 logwtmp(line, "", "");
1328 #  endif
1329         }
1330         /* FIXME: (ATL - if the need arises) What to do if we have
1331          * login, but no logout?  what if logout but no logwtmp? All
1332          * routines are in libutil so they should all be there,
1333          * but... */
1334 # endif
1335         return 1;
1336 }
1337
1338 int
1339 syslogin_write_entry(struct logininfo *li)
1340 {
1341         switch (li->type) {
1342         case LTYPE_LOGIN:
1343                 return syslogin_perform_login(li);
1344         case LTYPE_LOGOUT:
1345                 return syslogin_perform_logout(li);
1346         default:
1347                 log("syslogin_write_entry: Invalid type field");
1348                 return 0;
1349         }
1350 }
1351 #endif /* USE_LOGIN */
1352
1353 /* end of file log-syslogin.c */
1354
1355 /**
1356  ** Low-level lastlog functions
1357  **/
1358
1359 #ifdef USE_LASTLOG
1360 #define LL_FILE 1
1361 #define LL_DIR 2
1362 #define LL_OTHER 3
1363
1364 static void
1365 lastlog_construct(struct logininfo *li, struct lastlog *last)
1366 {
1367         /* clear the structure */
1368         memset(last, '\0', sizeof(*last));
1369
1370         (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
1371         strlcpy(last->ll_host, li->hostname,
1372                 MIN_SIZEOF(last->ll_host, li->hostname));
1373         last->ll_time = li->tv_sec;
1374 }
1375
1376 static int
1377 lastlog_filetype(char *filename)
1378 {
1379         struct stat st;
1380
1381         if (stat(LASTLOG_FILE, &st) != 0) {
1382                 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
1383                         strerror(errno));
1384                 return 0;
1385         }
1386         if (S_ISDIR(st.st_mode))
1387                 return LL_DIR;
1388         else if (S_ISREG(st.st_mode))
1389                 return LL_FILE;
1390         else
1391                 return LL_OTHER;
1392 }
1393
1394
1395 /* open the file (using filemode) and seek to the login entry */
1396 static int
1397 lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1398 {
1399         off_t offset;
1400         int type;
1401         char lastlog_file[1024];
1402
1403         type = lastlog_filetype(LASTLOG_FILE);
1404         switch (type) {
1405                 case LL_FILE:
1406                         strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1407                         break;
1408                 case LL_DIR:
1409                         snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1410                                  LASTLOG_FILE, li->username);
1411                         break;
1412                 default:
1413                         log("lastlog_openseek: %.100s is not a file or directory!",
1414                             LASTLOG_FILE);
1415                         return 0;
1416         }
1417
1418         *fd = open(lastlog_file, filemode);
1419         if ( *fd < 0) {
1420                 debug("lastlog_openseek: Couldn't open %s: %s",
1421                     lastlog_file, strerror(errno));
1422                 return 0;
1423         }
1424
1425         if (type == LL_FILE) {
1426                 /* find this uid's offset in the lastlog file */
1427                 offset = (off_t) ( (long)li->uid * sizeof(struct lastlog));
1428
1429                 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1430                         log("lastlog_openseek: %s->lseek(): %s",
1431                          lastlog_file, strerror(errno));
1432                         return 0;
1433                 }
1434         }
1435
1436         return 1;
1437 }
1438
1439 static int
1440 lastlog_perform_login(struct logininfo *li)
1441 {
1442         struct lastlog last;
1443         int fd;
1444
1445         /* create our struct lastlog */
1446         lastlog_construct(li, &last);
1447
1448         if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1449                 return(0);
1450
1451         /* write the entry */
1452         if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1453                 close(fd);
1454                 log("lastlog_write_filemode: Error writing to %s: %s",
1455                     LASTLOG_FILE, strerror(errno));
1456                 return 0;
1457         }
1458
1459         close(fd);
1460         return 1;
1461 }
1462
1463 int
1464 lastlog_write_entry(struct logininfo *li)
1465 {
1466         switch(li->type) {
1467         case LTYPE_LOGIN:
1468                 return lastlog_perform_login(li);
1469         default:
1470                 log("lastlog_write_entry: Invalid type field");
1471                 return 0;
1472         }
1473 }
1474
1475 static void
1476 lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1477 {
1478         line_fullname(li->line, last->ll_line, sizeof(li->line));
1479         strlcpy(li->hostname, last->ll_host,
1480                 MIN_SIZEOF(li->hostname, last->ll_host));
1481         li->tv_sec = last->ll_time;
1482 }
1483
1484 int
1485 lastlog_get_entry(struct logininfo *li)
1486 {
1487         struct lastlog last;
1488         int fd;
1489
1490         if (lastlog_openseek(li, &fd, O_RDONLY)) {
1491                 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1492                         log("lastlog_get_entry: Error reading from %s: %s",
1493                             LASTLOG_FILE, strerror(errno));
1494                         return 0;
1495                 } else {
1496                         lastlog_populate_entry(li, &last);
1497                         return 1;
1498                 }
1499         } else {
1500                 return 0;
1501         }
1502 }
1503 #endif /* USE_LASTLOG */