loginrec.c

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