blob: 0a5fefad364ce482fa11dd24b88526dac6004d92 [file] [log] [blame]
andre2ff7b5d2000-06-03 14:57:40 +00001/*
2 * Copyright (c) 2000 Andre Lucas. All rights reserved.
andre61e67252000-06-04 17:07:49 +00003 * Portions copyright (c) 1998 Todd C. Miller
4 * Portions copyright (c) 1996 Jason Downs
5 * Portions copyright (c) 1996 Theo de Raadt
andre2ff7b5d2000-06-03 14:57:40 +00006 *
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
Kevin Stevesef4eea92001-02-05 12:42:17 +000033/**
andre2ff7b5d2000-06-03 14:57:40 +000034 ** loginrec.c: platform-independent login recording and lastlog retrieval
35 **/
36
andre61e67252000-06-04 17:07:49 +000037/*
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.
Kevin Stevesef4eea92001-02-05 12:42:17 +000066
andre61e67252000-06-04 17:07:49 +000067 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 --------------------
Kevin Stevesef4eea92001-02-05 12:42:17 +000085
andre61e67252000-06-04 17:07:49 +000086 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 -------------------------------
Kevin Stevesef4eea92001-02-05 12:42:17 +000092
andre61e67252000-06-04 17:07:49 +000093 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
Tim Riceb89e6942001-10-29 18:50:39 -0800126 configure.ac and loginrec.c. (You have to build logintest yourself
andre61e67252000-06-04 17:07:49 +0000127 with 'make logintest' as it's not built by default.)
128
129 Otherwise, patches to the specific method(s) are very helpful!
Kevin Stevesef4eea92001-02-05 12:42:17 +0000130
andre61e67252000-06-04 17:07:49 +0000131*/
132
andre2ff7b5d2000-06-03 14:57:40 +0000133/**
134 ** TODO:
Damien Millere5192fa2000-08-29 14:30:37 +1100135 ** homegrown ttyslot()
andre61e67252000-06-04 17:07:49 +0000136 ** test, test, test
andre2ff7b5d2000-06-03 14:57:40 +0000137 **
138 ** Platform status:
139 ** ----------------
140 **
141 ** Known good:
Damien Millere5192fa2000-08-29 14:30:37 +1100142 ** Linux (Redhat 6.2, Debian)
143 ** Solaris
andre2ff7b5d2000-06-03 14:57:40 +0000144 ** HP-UX 10.20 (gcc only)
andre6bb92372000-06-19 08:20:03 +0000145 ** IRIX
Ben Lindstromdcca9812000-11-10 03:28:31 +0000146 ** NeXT - M68k/HPPA/Sparc (4.2/3.3)
andre2ff7b5d2000-06-03 14:57:40 +0000147 **
148 ** Testing required: Please send reports!
andre2ff7b5d2000-06-03 14:57:40 +0000149 ** NetBSD
150 ** HP-UX 11
andre60f3c982000-06-03 16:18:19 +0000151 ** AIX
andre2ff7b5d2000-06-03 14:57:40 +0000152 **
153 ** Platforms with known problems:
Damien Millere5192fa2000-08-29 14:30:37 +1100154 ** Some variants of Slackware Linux
andre2ff7b5d2000-06-03 14:57:40 +0000155 **
156 **/
157
158#include "includes.h"
159
andre2ff7b5d2000-06-03 14:57:40 +0000160#include "ssh.h"
161#include "xmalloc.h"
162#include "loginrec.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +0000163#include "log.h"
164#include "atomicio.h"
andre2ff7b5d2000-06-03 14:57:40 +0000165
Damien Miller7df881d2003-01-07 16:46:58 +1100166RCSID("$Id: loginrec.c,v 1.46 2003/01/07 05:46:58 djm Exp $");
Ben Lindstromdcca9812000-11-10 03:28:31 +0000167
168#ifdef HAVE_UTIL_H
169# include <util.h>
170#endif
andre2ff7b5d2000-06-03 14:57:40 +0000171
Ben Lindstrome2fb8d32000-12-28 00:07:07 +0000172#ifdef HAVE_LIBUTIL_H
173# include <libutil.h>
174#endif
175
andre2ff7b5d2000-06-03 14:57:40 +0000176/**
177 ** prototypes for helper functions in this file
178 **/
179
180#if HAVE_UTMP_H
andre2ff7b5d2000-06-03 14:57:40 +0000181void set_utmp_time(struct logininfo *li, struct utmp *ut);
182void construct_utmp(struct logininfo *li, struct utmp *ut);
183#endif
184
185#ifdef HAVE_UTMPX_H
andre2ff7b5d2000-06-03 14:57:40 +0000186void set_utmpx_time(struct logininfo *li, struct utmpx *ut);
187void construct_utmpx(struct logininfo *li, struct utmpx *ut);
188#endif
189
190int utmp_write_entry(struct logininfo *li);
191int utmpx_write_entry(struct logininfo *li);
192int wtmp_write_entry(struct logininfo *li);
193int wtmpx_write_entry(struct logininfo *li);
194int lastlog_write_entry(struct logininfo *li);
195int syslogin_write_entry(struct logininfo *li);
196
197int getlast_entry(struct logininfo *li);
198int lastlog_get_entry(struct logininfo *li);
199int wtmp_get_entry(struct logininfo *li);
200int wtmpx_get_entry(struct logininfo *li);
201
andre6bb92372000-06-19 08:20:03 +0000202/* pick the shortest string */
203#define MIN_SIZEOF(s1,s2) ( sizeof(s1) < sizeof(s2) ? sizeof(s1) : sizeof(s2) )
204
andre2ff7b5d2000-06-03 14:57:40 +0000205/**
206 ** platform-independent login functions
207 **/
208
andre6bb92372000-06-19 08:20:03 +0000209/* login_login(struct logininfo *) -Record a login
Kevin Stevesef4eea92001-02-05 12:42:17 +0000210 *
andre6bb92372000-06-19 08:20:03 +0000211 * 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 */
andre61e67252000-06-04 17:07:49 +0000218int
219login_login (struct logininfo *li)
220{
221 li->type = LTYPE_LOGIN;
222 return login_write(li);
223}
224
225
andre6bb92372000-06-19 08:20:03 +0000226/* 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 */
andre61e67252000-06-04 17:07:49 +0000234int
235login_logout(struct logininfo *li)
236{
237 li->type = LTYPE_LOGOUT;
238 return login_write(li);
239}
240
andre6bb92372000-06-19 08:20:03 +0000241/* 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 */
andre61e67252000-06-04 17:07:49 +0000258unsigned int
259login_get_lastlog_time(const int uid)
260{
261 struct logininfo li;
262
andre6bb92372000-06-19 08:20:03 +0000263 if (login_get_lastlog(&li, uid))
264 return li.tv_sec;
265 else
266 return 0;
andre61e67252000-06-04 17:07:49 +0000267}
268
andre6bb92372000-06-19 08:20:03 +0000269/* 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 */
andre61e67252000-06-04 17:07:49 +0000282struct logininfo *
283login_get_lastlog(struct logininfo *li, const int uid)
284{
andre6bb92372000-06-19 08:20:03 +0000285 struct passwd *pw;
andre6bb92372000-06-19 08:20:03 +0000286
Damien Miller348c9b72000-08-15 10:01:22 +1000287 memset(li, '\0', sizeof(*li));
andre61e67252000-06-04 17:07:49 +0000288 li->uid = uid;
andre6bb92372000-06-19 08:20:03 +0000289
Kevin Stevesef4eea92001-02-05 12:42:17 +0000290 /*
Damien Miller53c5d462000-06-28 00:50:50 +1000291 * If we don't have a 'real' lastlog, we need the username to
andre6bb92372000-06-19 08:20:03 +0000292 * reliably search wtmp(x) for the last login (see
Kevin Stevesef4eea92001-02-05 12:42:17 +0000293 * wtmp_get_entry().)
Damien Miller53c5d462000-06-28 00:50:50 +1000294 */
andre6bb92372000-06-19 08:20:03 +0000295 pw = getpwuid(uid);
Damien Millerdd47aa22000-06-27 11:18:27 +1000296 if (pw == NULL)
297 fatal("login_get_lastlog: Cannot find account for uid %i", uid);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000298
andre98cabe02000-06-19 09:11:30 +0000299 /* No MIN_SIZEOF here - we absolutely *must not* truncate the
Kevin Stevesef4eea92001-02-05 12:42:17 +0000300 * username */
Damien Millerf8af08d2000-06-27 09:40:06 +1000301 strlcpy(li->username, pw->pw_name, sizeof(li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000302
andre61e67252000-06-04 17:07:49 +0000303 if (getlast_entry(li))
304 return li;
305 else
Damien Millerdd47aa22000-06-27 11:18:27 +1000306 return NULL;
andre61e67252000-06-04 17:07:49 +0000307}
308
309
andre6bb92372000-06-19 08:20:03 +0000310/* login_alloc_entry(int, char*, char*, char*) - Allocate and initialise
Kevin Stevesef4eea92001-02-05 12:42:17 +0000311 * a logininfo structure
312 *
andre6bb92372000-06-19 08:20:03 +0000313 * 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 */
andre61e67252000-06-04 17:07:49 +0000319struct
320logininfo *login_alloc_entry(int pid, const char *username,
321 const char *hostname, const char *line)
322{
andre2ff7b5d2000-06-03 14:57:40 +0000323 struct logininfo *newli;
324
Damien Miller348c9b72000-08-15 10:01:22 +1000325 newli = (struct logininfo *) xmalloc (sizeof(*newli));
andre61e67252000-06-04 17:07:49 +0000326 (void)login_init_entry(newli, pid, username, hostname, line);
327 return newli;
328}
andre2ff7b5d2000-06-03 14:57:40 +0000329
330
andre6bb92372000-06-19 08:20:03 +0000331/* login_free_entry(struct logininfo *) - free struct memory */
andre61e67252000-06-04 17:07:49 +0000332void
333login_free_entry(struct logininfo *li)
334{
335 xfree(li);
336}
337
andre2ff7b5d2000-06-03 14:57:40 +0000338
andre6bb92372000-06-19 08:20:03 +0000339/* login_init_entry(struct logininfo *, int, char*, char*, char*)
340 * - initialise a struct logininfo
Kevin Stevesef4eea92001-02-05 12:42:17 +0000341 *
andre6bb92372000-06-19 08:20:03 +0000342 * 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 */
andre61e67252000-06-04 17:07:49 +0000347int
Kevin Stevesef4eea92001-02-05 12:42:17 +0000348login_init_entry(struct logininfo *li, int pid, const char *username,
andre61e67252000-06-04 17:07:49 +0000349 const char *hostname, const char *line)
350{
Damien Millerf8af08d2000-06-27 09:40:06 +1000351 struct passwd *pw;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000352
Damien Miller348c9b72000-08-15 10:01:22 +1000353 memset(li, 0, sizeof(*li));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000354
andre61e67252000-06-04 17:07:49 +0000355 li->pid = pid;
Damien Millerf8af08d2000-06-27 09:40:06 +1000356
andre2ff7b5d2000-06-03 14:57:40 +0000357 /* set the line information */
andre61e67252000-06-04 17:07:49 +0000358 if (line)
andre2ff7b5d2000-06-03 14:57:40 +0000359 line_fullname(li->line, line, sizeof(li->line));
andre2ff7b5d2000-06-03 14:57:40 +0000360
Damien Millerf8af08d2000-06-27 09:40:06 +1000361 if (username) {
andre2ff7b5d2000-06-03 14:57:40 +0000362 strlcpy(li->username, username, sizeof(li->username));
Damien Millerf8af08d2000-06-27 09:40:06 +1000363 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 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000368
andre61e67252000-06-04 17:07:49 +0000369 if (hostname)
andre2ff7b5d2000-06-03 14:57:40 +0000370 strlcpy(li->hostname, hostname, sizeof(li->hostname));
Damien Millerf8af08d2000-06-27 09:40:06 +1000371
andre61e67252000-06-04 17:07:49 +0000372 return 1;
andre2ff7b5d2000-06-03 14:57:40 +0000373}
374
andre6bb92372000-06-19 08:20:03 +0000375/* 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 */
andre2ff7b5d2000-06-03 14:57:40 +0000381void
andre61e67252000-06-04 17:07:49 +0000382login_set_current_time(struct logininfo *li)
383{
andre2ff7b5d2000-06-03 14:57:40 +0000384 struct timeval tv;
385
386 gettimeofday(&tv, NULL);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000387
Damien Millerf8af08d2000-06-27 09:40:06 +1000388 li->tv_sec = tv.tv_sec;
389 li->tv_usec = tv.tv_usec;
andre2ff7b5d2000-06-03 14:57:40 +0000390}
391
andre61e67252000-06-04 17:07:49 +0000392/* copy a sockaddr_* into our logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000393void
andre61e67252000-06-04 17:07:49 +0000394login_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);
andre2ff7b5d2000-06-03 14:57:40 +0000404}
405
andre2ff7b5d2000-06-03 14:57:40 +0000406
andre61e67252000-06-04 17:07:49 +0000407/**
408 ** login_write: Call low-level recording functions based on autoconf
409 ** results
410 **/
andre2ff7b5d2000-06-03 14:57:40 +0000411int
andre61e67252000-06-04 17:07:49 +0000412login_write (struct logininfo *li)
413{
Damien Millerbac2d8a2000-09-05 16:13:06 +1100414#ifndef HAVE_CYGWIN
andre2ff7b5d2000-06-03 14:57:40 +0000415 if ((int)geteuid() != 0) {
416 log("Attempt to write login records by non-root user (aborting)");
417 return 1;
418 }
Damien Millerbac2d8a2000-09-05 16:13:06 +1100419#endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000420
andre2ff7b5d2000-06-03 14:57:40 +0000421 /* 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
Ben Lindstrom97c677d2001-05-08 20:33:05 +0000446#ifdef LOGIN_NEEDS_UTMPX
447int
448login_utmp_only(struct logininfo *li)
449{
450 li->type = LTYPE_LOGIN;
Ben Lindstrom9197c592001-10-26 15:56:55 +0000451 login_set_current_time(li);
Ben Lindstrom97c677d2001-05-08 20:33:05 +0000452# ifdef USE_UTMP
453 utmp_write_entry(li);
454# endif
455# ifdef USE_WTMP
456 wtmp_write_entry(li);
457# endif
458# ifdef USE_UTMPX
459 utmpx_write_entry(li);
460# endif
461# ifdef USE_WTMPX
462 wtmpx_write_entry(li);
463# endif
464 return 0;
465}
466#endif
467
andre2ff7b5d2000-06-03 14:57:40 +0000468/**
andre61e67252000-06-04 17:07:49 +0000469 ** getlast_entry: Call low-level functions to retrieve the last login
470 ** time.
andre2ff7b5d2000-06-03 14:57:40 +0000471 **/
472
andre61e67252000-06-04 17:07:49 +0000473/* take the uid in li and return the last login time */
474int
475getlast_entry(struct logininfo *li)
476{
477#ifdef USE_LASTLOG
Damien Miller53c5d462000-06-28 00:50:50 +1000478 return(lastlog_get_entry(li));
Damien Millerdd47aa22000-06-27 11:18:27 +1000479#else /* !USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000480
Damien Millerdd47aa22000-06-27 11:18:27 +1000481#ifdef DISABLE_LASTLOG
Kevin Stevesef4eea92001-02-05 12:42:17 +0000482 /* On some systems we shouldn't even try to obtain last login
andreecaabf12000-06-12 22:21:44 +0000483 * time, e.g. AIX */
484 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000485# else /* DISABLE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000486 /* Try to retrieve the last login time from wtmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000487# if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
andre61e67252000-06-04 17:07:49 +0000488 /* retrieve last login time from utmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000489 return (wtmp_get_entry(li));
490# else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
andre61e67252000-06-04 17:07:49 +0000491 /* If wtmp isn't available, try wtmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000492# if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
andre61e67252000-06-04 17:07:49 +0000493 /* retrieve last login time from utmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000494 return (wtmpx_get_entry(li));
495# else
andre61e67252000-06-04 17:07:49 +0000496 /* Give up: No means of retrieving last login time */
497 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000498# endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
499# endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000500# endif /* DISABLE_LASTLOG */
Damien Millerdd47aa22000-06-27 11:18:27 +1000501#endif /* USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000502}
503
504
505
andre2ff7b5d2000-06-03 14:57:40 +0000506/*
andre61e67252000-06-04 17:07:49 +0000507 * 'line' string utility functions
508 *
509 * These functions process the 'line' string into one of three forms:
510 *
andre2ff7b5d2000-06-03 14:57:40 +0000511 * 1. The full filename (including '/dev')
512 * 2. The stripped name (excluding '/dev')
andre61e67252000-06-04 17:07:49 +0000513 * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
514 * /dev/pts/1 -> ts/1 )
andre2ff7b5d2000-06-03 14:57:40 +0000515 *
516 * Form 3 is used on some systems to identify a .tmp.? entry when
517 * attempting to remove it. Typically both addition and removal is
andre61e67252000-06-04 17:07:49 +0000518 * performed by one application - say, sshd - so as long as the choice
519 * uniquely identifies a terminal it's ok.
andre2ff7b5d2000-06-03 14:57:40 +0000520 */
521
522
andre61e67252000-06-04 17:07:49 +0000523/* line_fullname(): add the leading '/dev/' if it doesn't exist make
524 * sure dst has enough space, if not just copy src (ugh) */
andre2ff7b5d2000-06-03 14:57:40 +0000525char *
andre61e67252000-06-04 17:07:49 +0000526line_fullname(char *dst, const char *src, int dstsize)
527{
andre2ff7b5d2000-06-03 14:57:40 +0000528 memset(dst, '\0', dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100529 if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
andre2ff7b5d2000-06-03 14:57:40 +0000530 strlcpy(dst, src, dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100531 } else {
Damien Miller1a132252000-06-13 21:23:17 +1000532 strlcpy(dst, "/dev/", dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000533 strlcat(dst, src, dstsize);
534 }
535 return dst;
536}
537
andre61e67252000-06-04 17:07:49 +0000538/* line_stripname(): strip the leading '/dev' if it exists, return dst */
andre2ff7b5d2000-06-03 14:57:40 +0000539char *
andre61e67252000-06-04 17:07:49 +0000540line_stripname(char *dst, const char *src, int dstsize)
541{
andre2ff7b5d2000-06-03 14:57:40 +0000542 memset(dst, '\0', dstsize);
543 if (strncmp(src, "/dev/", 5) == 0)
Damien Millerf5a81472000-09-30 21:34:44 +1100544 strlcpy(dst, src + 5, dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000545 else
546 strlcpy(dst, src, dstsize);
547 return dst;
andre61e67252000-06-04 17:07:49 +0000548}
549
andre61e67252000-06-04 17:07:49 +0000550/* line_abbrevname(): Return the abbreviated (usually four-character)
551 * form of the line (Just use the last <dstsize> characters of the
552 * full name.)
553 *
554 * NOTE: use strncpy because we do NOT necessarily want zero
555 * termination */
andre2ff7b5d2000-06-03 14:57:40 +0000556char *
Kevin Stevesef4eea92001-02-05 12:42:17 +0000557line_abbrevname(char *dst, const char *src, int dstsize)
Damien Millerdd47aa22000-06-27 11:18:27 +1000558{
559 size_t len;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000560
andre2ff7b5d2000-06-03 14:57:40 +0000561 memset(dst, '\0', dstsize);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000562
Damien Miller8e81ed32000-07-01 13:17:42 +1000563 /* Always skip prefix if present */
564 if (strncmp(src, "/dev/", 5) == 0)
565 src += 5;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000566
Damien Millerf1b9d112002-04-23 23:09:19 +1000567#ifdef WITH_ABBREV_NO_TTY
568 if (strncmp(src, "tty", 3) == 0)
569 src += 3;
570#endif
571
Damien Millerdd47aa22000-06-27 11:18:27 +1000572 len = strlen(src);
573
Damien Miller8e81ed32000-07-01 13:17:42 +1000574 if (len > 0) {
575 if (((int)len - dstsize) > 0)
576 src += ((int)len - dstsize);
577
578 /* note: _don't_ change this to strlcpy */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000579 strncpy(dst, src, (size_t)dstsize);
Damien Millerdd47aa22000-06-27 11:18:27 +1000580 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000581
andre2ff7b5d2000-06-03 14:57:40 +0000582 return dst;
583}
584
andre2ff7b5d2000-06-03 14:57:40 +0000585/**
586 ** utmp utility functions
andre61e67252000-06-04 17:07:49 +0000587 **
588 ** These functions manipulate struct utmp, taking system differences
589 ** into account.
andre2ff7b5d2000-06-03 14:57:40 +0000590 **/
591
592#if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
593
andre2ff7b5d2000-06-03 14:57:40 +0000594/* build the utmp structure */
595void
andre61e67252000-06-04 17:07:49 +0000596set_utmp_time(struct logininfo *li, struct utmp *ut)
597{
Damien Millerdd47aa22000-06-27 11:18:27 +1000598# ifdef HAVE_TV_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000599 ut->ut_tv.tv_sec = li->tv_sec;
600 ut->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000601# else
andre2ff7b5d2000-06-03 14:57:40 +0000602# ifdef HAVE_TIME_IN_UTMP
603 ut->ut_time = li->tv_sec;
604# endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000605# endif
andre2ff7b5d2000-06-03 14:57:40 +0000606}
607
608void
609construct_utmp(struct logininfo *li,
andre61e67252000-06-04 17:07:49 +0000610 struct utmp *ut)
611{
Damien Miller02e16ad2003-01-03 14:42:27 +1100612# ifdef HAVE_ADDR_V6_IN_UTMP
613 struct sockaddr_in6 *sa6;
614# endif
Damien Miller348c9b72000-08-15 10:01:22 +1000615 memset(ut, '\0', sizeof(*ut));
andre6bb92372000-06-19 08:20:03 +0000616
617 /* First fill out fields used for both logins and logouts */
618
Damien Millerdd47aa22000-06-27 11:18:27 +1000619# ifdef HAVE_ID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000620 line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000621# endif
andre2ff7b5d2000-06-03 14:57:40 +0000622
Damien Millerdd47aa22000-06-27 11:18:27 +1000623# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000624 /* This is done here to keep utmp constants out of struct logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000625 switch (li->type) {
626 case LTYPE_LOGIN:
627 ut->ut_type = USER_PROCESS;
Tim Rice81ed5182002-09-25 17:38:46 -0700628#ifdef _UNICOS
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000629 cray_set_tmpdir(ut);
630#endif
andre2ff7b5d2000-06-03 14:57:40 +0000631 break;
632 case LTYPE_LOGOUT:
633 ut->ut_type = DEAD_PROCESS;
Tim Rice81ed5182002-09-25 17:38:46 -0700634#ifdef _UNICOS
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000635 cray_retain_utmp(ut, li->pid);
636#endif
andre2ff7b5d2000-06-03 14:57:40 +0000637 break;
638 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000639# endif
andre6bb92372000-06-19 08:20:03 +0000640 set_utmp_time(li, ut);
andre2ff7b5d2000-06-03 14:57:40 +0000641
andre6bb92372000-06-19 08:20:03 +0000642 line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000643
644# ifdef HAVE_PID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000645 ut->ut_pid = li->pid;
Damien Millerdd47aa22000-06-27 11:18:27 +1000646# endif
andre6bb92372000-06-19 08:20:03 +0000647
648 /* If we're logging out, leave all other fields blank */
649 if (li->type == LTYPE_LOGOUT)
650 return;
651
Damien Millerdd47aa22000-06-27 11:18:27 +1000652 /*
653 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000654 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000655 */
andre6bb92372000-06-19 08:20:03 +0000656
657 /* Use strncpy because we don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000658 strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000659# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000660 strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000661# endif
662# ifdef HAVE_ADDR_IN_UTMP
andre61e67252000-06-04 17:07:49 +0000663 /* this is just a 32-bit IP address */
664 if (li->hostaddr.sa.sa_family == AF_INET)
665 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000666# endif
Damien Miller02e16ad2003-01-03 14:42:27 +1100667# ifdef HAVE_ADDR_V6_IN_UTMP
668 /* this is just a 128-bit IPv6 address */
669 if (li->hostaddr.sa.sa_family == AF_INET6) {
670 sa6 = ((struct sockaddr_in6 *)&li->hostaddr.sa);
671 memcpy(ut->ut_addr_v6, sa6->sin6_addr.s6_addr, 16);
672 if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr)) {
673 ut->ut_addr_v6[0] = ut->ut_addr_v6[3];
674 ut->ut_addr_v6[1] = 0;
675 ut->ut_addr_v6[2] = 0;
676 ut->ut_addr_v6[3] = 0;
677 }
678 }
679# endif
andre61e67252000-06-04 17:07:49 +0000680}
Damien Millerdd47aa22000-06-27 11:18:27 +1000681#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
andre61e67252000-06-04 17:07:49 +0000682
andre2ff7b5d2000-06-03 14:57:40 +0000683/**
684 ** utmpx utility functions
andre61e67252000-06-04 17:07:49 +0000685 **
686 ** These functions manipulate struct utmpx, accounting for system
687 ** variations.
andre2ff7b5d2000-06-03 14:57:40 +0000688 **/
689
690#if defined(USE_UTMPX) || defined (USE_WTMPX)
andre2ff7b5d2000-06-03 14:57:40 +0000691/* build the utmpx structure */
692void
andre61e67252000-06-04 17:07:49 +0000693set_utmpx_time(struct logininfo *li, struct utmpx *utx)
694{
Damien Millerdd47aa22000-06-27 11:18:27 +1000695# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000696 utx->ut_tv.tv_sec = li->tv_sec;
697 utx->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000698# else /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000699# ifdef HAVE_TIME_IN_UTMPX
700 utx->ut_time = li->tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000701# endif /* HAVE_TIME_IN_UTMPX */
702# endif /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000703}
704
andre61e67252000-06-04 17:07:49 +0000705void
706construct_utmpx(struct logininfo *li, struct utmpx *utx)
707{
Damien Miller02e16ad2003-01-03 14:42:27 +1100708# ifdef HAVE_ADDR_V6_IN_UTMP
709 struct sockaddr_in6 *sa6;
710# endif
Damien Miller348c9b72000-08-15 10:01:22 +1000711 memset(utx, '\0', sizeof(*utx));
Damien Miller8e81ed32000-07-01 13:17:42 +1000712# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000713 line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
Damien Miller8e81ed32000-07-01 13:17:42 +1000714# endif
andre2ff7b5d2000-06-03 14:57:40 +0000715
716 /* this is done here to keep utmp constants out of loginrec.h */
717 switch (li->type) {
718 case LTYPE_LOGIN:
719 utx->ut_type = USER_PROCESS;
720 break;
721 case LTYPE_LOGOUT:
722 utx->ut_type = DEAD_PROCESS;
723 break;
724 }
andre2ff7b5d2000-06-03 14:57:40 +0000725 line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
andre2ff7b5d2000-06-03 14:57:40 +0000726 set_utmpx_time(li, utx);
andre6bb92372000-06-19 08:20:03 +0000727 utx->ut_pid = li->pid;
Tim Ricee06ae4a2002-02-24 17:56:46 -0800728 /* strncpy(): Don't necessarily want null termination */
729 strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
andre6bb92372000-06-19 08:20:03 +0000730
731 if (li->type == LTYPE_LOGOUT)
732 return;
733
Damien Millerdd47aa22000-06-27 11:18:27 +1000734 /*
735 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000736 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000737 */
andre6bb92372000-06-19 08:20:03 +0000738
Damien Millerdd47aa22000-06-27 11:18:27 +1000739# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000740 strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000741# endif
742# ifdef HAVE_ADDR_IN_UTMPX
Damien Millerd6f204d2000-09-23 13:57:27 +1100743 /* this is just a 32-bit IP address */
744 if (li->hostaddr.sa.sa_family == AF_INET)
745 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Damien Millerdd47aa22000-06-27 11:18:27 +1000746# endif
Damien Miller02e16ad2003-01-03 14:42:27 +1100747# ifdef HAVE_ADDR_V6_IN_UTMP
748 /* this is just a 128-bit IPv6 address */
749 if (li->hostaddr.sa.sa_family == AF_INET6) {
750 sa6 = ((struct sockaddr_in6 *)&li->hostaddr.sa);
751 memcpy(ut->ut_addr_v6, sa6->sin6_addr.s6_addr, 16);
752 if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr)) {
753 ut->ut_addr_v6[0] = ut->ut_addr_v6[3];
754 ut->ut_addr_v6[1] = 0;
755 ut->ut_addr_v6[2] = 0;
756 ut->ut_addr_v6[3] = 0;
757 }
758 }
759# endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000760# ifdef HAVE_SYSLEN_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000761 /* ut_syslen is the length of the utx_host string */
762 utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +1000763# endif
andre61e67252000-06-04 17:07:49 +0000764}
Damien Millerdd47aa22000-06-27 11:18:27 +1000765#endif /* USE_UTMPX || USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000766
767/**
andre61e67252000-06-04 17:07:49 +0000768 ** Low-level utmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000769 **/
770
771/* FIXME: (ATL) utmp_write_direct needs testing */
andre2ff7b5d2000-06-03 14:57:40 +0000772#ifdef USE_UTMP
773
andre2ff7b5d2000-06-03 14:57:40 +0000774/* if we can, use pututline() etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000775# if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
776 defined(HAVE_PUTUTLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000777# define UTMP_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000778# endif
andre2ff7b5d2000-06-03 14:57:40 +0000779
780
781/* write a utmp entry with the system's help (pututline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000782# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000783static int
andre61e67252000-06-04 17:07:49 +0000784utmp_write_library(struct logininfo *li, struct utmp *ut)
785{
andre2ff7b5d2000-06-03 14:57:40 +0000786 setutent();
787 pututline(ut);
788
Damien Millerdd47aa22000-06-27 11:18:27 +1000789# ifdef HAVE_ENDUTENT
andre2ff7b5d2000-06-03 14:57:40 +0000790 endutent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000791# endif
andre2ff7b5d2000-06-03 14:57:40 +0000792 return 1;
andre61e67252000-06-04 17:07:49 +0000793}
Damien Millerdd47aa22000-06-27 11:18:27 +1000794# else /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000795
796/* write a utmp entry direct to the file */
andre61e67252000-06-04 17:07:49 +0000797/* This is a slightly modification of code in OpenBSD's login.c */
andre2ff7b5d2000-06-03 14:57:40 +0000798static int
andre61e67252000-06-04 17:07:49 +0000799utmp_write_direct(struct logininfo *li, struct utmp *ut)
800{
andre2ff7b5d2000-06-03 14:57:40 +0000801 struct utmp old_ut;
802 register int fd;
803 int tty;
804
andre6bb92372000-06-19 08:20:03 +0000805 /* FIXME: (ATL) ttyslot() needs local implementation */
Damien Miller348c9b72000-08-15 10:01:22 +1000806
Damien Millere5192fa2000-08-29 14:30:37 +1100807#if defined(HAVE_GETTTYENT)
Damien Miller348c9b72000-08-15 10:01:22 +1000808 register struct ttyent *ty;
809
810 tty=0;
811
812 setttyent();
813 while ((struct ttyent *)0 != (ty = getttyent())) {
814 tty++;
815 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
816 break;
817 }
818 endttyent();
819
820 if((struct ttyent *)0 == ty) {
821 log("utmp_write_entry: tty not found");
822 return(1);
823 }
824#else /* FIXME */
825
andre2ff7b5d2000-06-03 14:57:40 +0000826 tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
827
Damien Millere5192fa2000-08-29 14:30:37 +1100828#endif /* HAVE_GETTTYENT */
Damien Miller348c9b72000-08-15 10:01:22 +1000829
andre2ff7b5d2000-06-03 14:57:40 +0000830 if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
831 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
832 /*
833 * Prevent luser from zero'ing out ut_host.
834 * If the new ut_line is empty but the old one is not
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000835 * and ut_line and ut_name match, preserve the old ut_line.
andre2ff7b5d2000-06-03 14:57:40 +0000836 */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000837 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
838 (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
839 (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000840 (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
andre2ff7b5d2000-06-03 14:57:40 +0000841 (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
Damien Miller53c5d462000-06-28 00:50:50 +1000842 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000843
andre2ff7b5d2000-06-03 14:57:40 +0000844 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
Damien Miller36ccb5c2000-08-09 16:34:27 +1000845 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
andre2ff7b5d2000-06-03 14:57:40 +0000846 log("utmp_write_direct: error writing %s: %s",
andre6bb92372000-06-19 08:20:03 +0000847 UTMP_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000848
andre2ff7b5d2000-06-03 14:57:40 +0000849 (void)close(fd);
850 return 1;
Damien Miller53c5d462000-06-28 00:50:50 +1000851 } else {
andre2ff7b5d2000-06-03 14:57:40 +0000852 return 0;
Damien Miller53c5d462000-06-28 00:50:50 +1000853 }
andre61e67252000-06-04 17:07:49 +0000854}
Damien Millerdd47aa22000-06-27 11:18:27 +1000855# endif /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000856
857static int
andre61e67252000-06-04 17:07:49 +0000858utmp_perform_login(struct logininfo *li)
859{
andre2ff7b5d2000-06-03 14:57:40 +0000860 struct utmp ut;
861
862 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000863# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000864 if (!utmp_write_library(li, &ut)) {
andre6bb92372000-06-19 08:20:03 +0000865 log("utmp_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000866 return 0;
867 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000868# else
andre2ff7b5d2000-06-03 14:57:40 +0000869 if (!utmp_write_direct(li, &ut)) {
870 log("utmp_perform_login: utmp_write_direct() failed");
871 return 0;
872 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000873# endif
andre2ff7b5d2000-06-03 14:57:40 +0000874 return 1;
andre61e67252000-06-04 17:07:49 +0000875}
andre2ff7b5d2000-06-03 14:57:40 +0000876
877
878static int
andre61e67252000-06-04 17:07:49 +0000879utmp_perform_logout(struct logininfo *li)
880{
andre2ff7b5d2000-06-03 14:57:40 +0000881 struct utmp ut;
882
andre6bb92372000-06-19 08:20:03 +0000883 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000884# ifdef UTMP_USE_LIBRARY
andre6bb92372000-06-19 08:20:03 +0000885 if (!utmp_write_library(li, &ut)) {
886 log("utmp_perform_logout: utmp_write_library() failed");
887 return 0;
888 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000889# else
andre6bb92372000-06-19 08:20:03 +0000890 if (!utmp_write_direct(li, &ut)) {
891 log("utmp_perform_logout: utmp_write_direct() failed");
892 return 0;
893 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000894# endif
andre2ff7b5d2000-06-03 14:57:40 +0000895 return 1;
andre61e67252000-06-04 17:07:49 +0000896}
andre2ff7b5d2000-06-03 14:57:40 +0000897
898
899int
andre61e67252000-06-04 17:07:49 +0000900utmp_write_entry(struct logininfo *li)
901{
andre2ff7b5d2000-06-03 14:57:40 +0000902 switch(li->type) {
903 case LTYPE_LOGIN:
904 return utmp_perform_login(li);
905
906 case LTYPE_LOGOUT:
907 return utmp_perform_logout(li);
908
909 default:
910 log("utmp_write_entry: invalid type field");
911 return 0;
912 }
andre61e67252000-06-04 17:07:49 +0000913}
Damien Millerdd47aa22000-06-27 11:18:27 +1000914#endif /* USE_UTMP */
andre2ff7b5d2000-06-03 14:57:40 +0000915
916
917/**
andre61e67252000-06-04 17:07:49 +0000918 ** Low-level utmpx functions
andre2ff7b5d2000-06-03 14:57:40 +0000919 **/
920
921/* not much point if we don't want utmpx entries */
922#ifdef USE_UTMPX
923
andre2ff7b5d2000-06-03 14:57:40 +0000924/* if we have the wherewithall, use pututxline etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000925# if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
926 defined(HAVE_PUTUTXLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000927# define UTMPX_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000928# endif
andre2ff7b5d2000-06-03 14:57:40 +0000929
930
931/* write a utmpx entry with the system's help (pututxline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000932# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000933static int
andre61e67252000-06-04 17:07:49 +0000934utmpx_write_library(struct logininfo *li, struct utmpx *utx)
935{
andre2ff7b5d2000-06-03 14:57:40 +0000936 setutxent();
937 pututxline(utx);
938
Damien Millerdd47aa22000-06-27 11:18:27 +1000939# ifdef HAVE_ENDUTXENT
andre2ff7b5d2000-06-03 14:57:40 +0000940 endutxent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000941# endif
andre2ff7b5d2000-06-03 14:57:40 +0000942 return 1;
andre61e67252000-06-04 17:07:49 +0000943}
andre2ff7b5d2000-06-03 14:57:40 +0000944
Damien Millerdd47aa22000-06-27 11:18:27 +1000945# else /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000946
947/* write a utmp entry direct to the file */
948static int
andre61e67252000-06-04 17:07:49 +0000949utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000950{
andre2ff7b5d2000-06-03 14:57:40 +0000951 log("utmpx_write_direct: not implemented!");
952 return 0;
andre61e67252000-06-04 17:07:49 +0000953}
Damien Millerdd47aa22000-06-27 11:18:27 +1000954# endif /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000955
956static int
andre61e67252000-06-04 17:07:49 +0000957utmpx_perform_login(struct logininfo *li)
958{
andre2ff7b5d2000-06-03 14:57:40 +0000959 struct utmpx utx;
960
961 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000962# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000963 if (!utmpx_write_library(li, &utx)) {
964 log("utmpx_perform_login: utmp_write_library() failed");
965 return 0;
966 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000967# else
andre2ff7b5d2000-06-03 14:57:40 +0000968 if (!utmpx_write_direct(li, &ut)) {
969 log("utmpx_perform_login: utmp_write_direct() failed");
970 return 0;
971 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000972# endif
andre2ff7b5d2000-06-03 14:57:40 +0000973 return 1;
andre61e67252000-06-04 17:07:49 +0000974}
andre2ff7b5d2000-06-03 14:57:40 +0000975
976
977static int
andre61e67252000-06-04 17:07:49 +0000978utmpx_perform_logout(struct logininfo *li)
979{
andre2ff7b5d2000-06-03 14:57:40 +0000980 struct utmpx utx;
981
Tim Ricee06ae4a2002-02-24 17:56:46 -0800982 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000983# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000984 line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000985# endif
986# ifdef HAVE_TYPE_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000987 utx.ut_type = DEAD_PROCESS;
Damien Millerdd47aa22000-06-27 11:18:27 +1000988# endif
andre2ff7b5d2000-06-03 14:57:40 +0000989
Damien Millerdd47aa22000-06-27 11:18:27 +1000990# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000991 utmpx_write_library(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000992# else
andre2ff7b5d2000-06-03 14:57:40 +0000993 utmpx_write_direct(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000994# endif
andre2ff7b5d2000-06-03 14:57:40 +0000995 return 1;
andre61e67252000-06-04 17:07:49 +0000996}
andre2ff7b5d2000-06-03 14:57:40 +0000997
andre2ff7b5d2000-06-03 14:57:40 +0000998int
andre61e67252000-06-04 17:07:49 +0000999utmpx_write_entry(struct logininfo *li)
1000{
andre2ff7b5d2000-06-03 14:57:40 +00001001 switch(li->type) {
1002 case LTYPE_LOGIN:
1003 return utmpx_perform_login(li);
1004 case LTYPE_LOGOUT:
1005 return utmpx_perform_logout(li);
1006 default:
1007 log("utmpx_write_entry: invalid type field");
1008 return 0;
1009 }
andre61e67252000-06-04 17:07:49 +00001010}
Damien Millerdd47aa22000-06-27 11:18:27 +10001011#endif /* USE_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001012
1013
1014/**
andre61e67252000-06-04 17:07:49 +00001015 ** Low-level wtmp functions
andre2ff7b5d2000-06-03 14:57:40 +00001016 **/
1017
Kevin Stevesef4eea92001-02-05 12:42:17 +00001018#ifdef USE_WTMP
andre2ff7b5d2000-06-03 14:57:40 +00001019
andre2ff7b5d2000-06-03 14:57:40 +00001020/* write a wtmp entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001021/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001022static int
andre61e67252000-06-04 17:07:49 +00001023wtmp_write(struct logininfo *li, struct utmp *ut)
1024{
andre2ff7b5d2000-06-03 14:57:40 +00001025 struct stat buf;
1026 int fd, ret = 1;
1027
1028 if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1029 log("wtmp_write: problem writing %s: %s",
1030 WTMP_FILE, strerror(errno));
1031 return 0;
1032 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001033 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001034 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001035 ftruncate(fd, buf.st_size);
1036 log("wtmp_write: problem writing %s: %s",
1037 WTMP_FILE, strerror(errno));
1038 ret = 0;
1039 }
1040 (void)close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001041 return ret;
andre61e67252000-06-04 17:07:49 +00001042}
andre2ff7b5d2000-06-03 14:57:40 +00001043
andre2ff7b5d2000-06-03 14:57:40 +00001044static int
Damien Millerdd47aa22000-06-27 11:18:27 +10001045wtmp_perform_login(struct logininfo *li)
1046{
andre2ff7b5d2000-06-03 14:57:40 +00001047 struct utmp ut;
1048
1049 construct_utmp(li, &ut);
1050 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001051}
andre2ff7b5d2000-06-03 14:57:40 +00001052
1053
1054static int
andre61e67252000-06-04 17:07:49 +00001055wtmp_perform_logout(struct logininfo *li)
1056{
andre2ff7b5d2000-06-03 14:57:40 +00001057 struct utmp ut;
1058
1059 construct_utmp(li, &ut);
andre2ff7b5d2000-06-03 14:57:40 +00001060 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001061}
andre2ff7b5d2000-06-03 14:57:40 +00001062
1063
1064int
andre61e67252000-06-04 17:07:49 +00001065wtmp_write_entry(struct logininfo *li)
1066{
andre2ff7b5d2000-06-03 14:57:40 +00001067 switch(li->type) {
1068 case LTYPE_LOGIN:
1069 return wtmp_perform_login(li);
1070 case LTYPE_LOGOUT:
1071 return wtmp_perform_logout(li);
1072 default:
1073 log("wtmp_write_entry: invalid type field");
1074 return 0;
1075 }
andre61e67252000-06-04 17:07:49 +00001076}
andre2ff7b5d2000-06-03 14:57:40 +00001077
1078
andre6bb92372000-06-19 08:20:03 +00001079/* Notes on fetching login data from wtmp/wtmpx
Kevin Stevesef4eea92001-02-05 12:42:17 +00001080 *
andre6bb92372000-06-19 08:20:03 +00001081 * Logouts are usually recorded with (amongst other things) a blank
1082 * username on a given tty line. However, some systems (HP-UX is one)
1083 * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1084 *
1085 * Since we're only looking for logins here, we know that the username
1086 * must be set correctly. On systems that leave it in, we check for
1087 * ut_type==USER_PROCESS (indicating a login.)
1088 *
1089 * Portability: Some systems may set something other than USER_PROCESS
1090 * to indicate a login process. I don't know of any as I write. Also,
1091 * it's possible that some systems may both leave the username in
1092 * place and not have ut_type.
1093 */
1094
andre6bb92372000-06-19 08:20:03 +00001095/* return true if this wtmp entry indicates a login */
1096static int
1097wtmp_islogin(struct logininfo *li, struct utmp *ut)
1098{
Kevin Stevesef4eea92001-02-05 12:42:17 +00001099 if (strncmp(li->username, ut->ut_name,
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001100 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001101# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001102 if (ut->ut_type & USER_PROCESS)
1103 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001104# else
andre6bb92372000-06-19 08:20:03 +00001105 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001106# endif
andre6bb92372000-06-19 08:20:03 +00001107 }
1108 return 0;
1109}
1110
andre2ff7b5d2000-06-03 14:57:40 +00001111int
andre61e67252000-06-04 17:07:49 +00001112wtmp_get_entry(struct logininfo *li)
1113{
andre2ff7b5d2000-06-03 14:57:40 +00001114 struct stat st;
1115 struct utmp ut;
andre6bb92372000-06-19 08:20:03 +00001116 int fd, found=0;
1117
1118 /* Clear the time entries in our logininfo */
1119 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001120
1121 if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1122 log("wtmp_get_entry: problem opening %s: %s",
1123 WTMP_FILE, strerror(errno));
1124 return 0;
1125 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001126 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001127 log("wtmp_get_entry: couldn't stat %s: %s",
1128 WTMP_FILE, strerror(errno));
1129 close(fd);
1130 return 0;
1131 }
andre2ff7b5d2000-06-03 14:57:40 +00001132
andre6bb92372000-06-19 08:20:03 +00001133 /* Seek to the start of the last struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001134 if (lseek(fd, -(off_t)sizeof(struct utmp), SEEK_END) == -1) {
andre6bb92372000-06-19 08:20:03 +00001135 /* Looks like we've got a fresh wtmp file */
1136 close(fd);
1137 return 0;
1138 }
1139
1140 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001141 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001142 log("wtmp_get_entry: read of %s failed: %s",
1143 WTMP_FILE, strerror(errno));
1144 close (fd);
1145 return 0;
1146 }
andre6bb92372000-06-19 08:20:03 +00001147 if ( wtmp_islogin(li, &ut) ) {
1148 found = 1;
1149 /* We've already checked for a time in struct
1150 * utmp, in login_getlast(). */
Damien Millerdd47aa22000-06-27 11:18:27 +10001151# ifdef HAVE_TIME_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +00001152 li->tv_sec = ut.ut_time;
Damien Millerdd47aa22000-06-27 11:18:27 +10001153# else
andre2ff7b5d2000-06-03 14:57:40 +00001154# if HAVE_TV_IN_UTMP
1155 li->tv_sec = ut.ut_tv.tv_sec;
1156# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001157# endif
andre6bb92372000-06-19 08:20:03 +00001158 line_fullname(li->line, ut.ut_line,
1159 MIN_SIZEOF(li->line, ut.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001160# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001161 strlcpy(li->hostname, ut.ut_host,
1162 MIN_SIZEOF(li->hostname, ut.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001163# endif
andre6bb92372000-06-19 08:20:03 +00001164 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001165 }
andre6bb92372000-06-19 08:20:03 +00001166 /* Seek back 2 x struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001167 if (lseek(fd, -(off_t)(2 * sizeof(struct utmp)), SEEK_CUR) == -1) {
andre6bb92372000-06-19 08:20:03 +00001168 /* We've found the start of the file, so quit */
andre2ff7b5d2000-06-03 14:57:40 +00001169 close (fd);
1170 return 0;
1171 }
andre6bb92372000-06-19 08:20:03 +00001172 }
1173
1174 /* We found an entry. Tidy up and return */
1175 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001176 return 1;
andre61e67252000-06-04 17:07:49 +00001177}
Damien Millerdd47aa22000-06-27 11:18:27 +10001178# endif /* USE_WTMP */
andre2ff7b5d2000-06-03 14:57:40 +00001179
1180
1181/**
andre61e67252000-06-04 17:07:49 +00001182 ** Low-level wtmpx functions
andre2ff7b5d2000-06-03 14:57:40 +00001183 **/
1184
1185#ifdef USE_WTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001186/* write a wtmpx entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001187/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001188static int
andre61e67252000-06-04 17:07:49 +00001189wtmpx_write(struct logininfo *li, struct utmpx *utx)
1190{
andre2ff7b5d2000-06-03 14:57:40 +00001191 struct stat buf;
1192 int fd, ret = 1;
1193
1194 if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1195 log("wtmpx_write: problem opening %s: %s",
1196 WTMPX_FILE, strerror(errno));
1197 return 0;
1198 }
1199
Kevin Stevesef4eea92001-02-05 12:42:17 +00001200 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001201 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001202 ftruncate(fd, buf.st_size);
1203 log("wtmpx_write: problem writing %s: %s",
1204 WTMPX_FILE, strerror(errno));
1205 ret = 0;
1206 }
1207 (void)close(fd);
1208
1209 return ret;
andre61e67252000-06-04 17:07:49 +00001210}
andre2ff7b5d2000-06-03 14:57:40 +00001211
1212
1213static int
andre61e67252000-06-04 17:07:49 +00001214wtmpx_perform_login(struct logininfo *li)
1215{
andre2ff7b5d2000-06-03 14:57:40 +00001216 struct utmpx utx;
1217
1218 construct_utmpx(li, &utx);
1219 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001220}
andre2ff7b5d2000-06-03 14:57:40 +00001221
1222
1223static int
andre61e67252000-06-04 17:07:49 +00001224wtmpx_perform_logout(struct logininfo *li)
1225{
andre2ff7b5d2000-06-03 14:57:40 +00001226 struct utmpx utx;
1227
1228 construct_utmpx(li, &utx);
andre2ff7b5d2000-06-03 14:57:40 +00001229 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001230}
andre2ff7b5d2000-06-03 14:57:40 +00001231
1232
1233int
andre61e67252000-06-04 17:07:49 +00001234wtmpx_write_entry(struct logininfo *li)
1235{
andre2ff7b5d2000-06-03 14:57:40 +00001236 switch(li->type) {
1237 case LTYPE_LOGIN:
1238 return wtmpx_perform_login(li);
1239 case LTYPE_LOGOUT:
1240 return wtmpx_perform_logout(li);
1241 default:
1242 log("wtmpx_write_entry: invalid type field");
1243 return 0;
1244 }
andre61e67252000-06-04 17:07:49 +00001245}
andre2ff7b5d2000-06-03 14:57:40 +00001246
andre6bb92372000-06-19 08:20:03 +00001247/* Please see the notes above wtmp_islogin() for information about the
1248 next two functions */
1249
1250/* Return true if this wtmpx entry indicates a login */
1251static int
1252wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1253{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001254 if ( strncmp(li->username, utx->ut_name,
1255 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001256# ifdef HAVE_TYPE_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001257 if (utx->ut_type == USER_PROCESS)
1258 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001259# else
andre6bb92372000-06-19 08:20:03 +00001260 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001261# endif
andre6bb92372000-06-19 08:20:03 +00001262 }
1263 return 0;
1264}
1265
andre2ff7b5d2000-06-03 14:57:40 +00001266
1267int
andre61e67252000-06-04 17:07:49 +00001268wtmpx_get_entry(struct logininfo *li)
1269{
andre2ff7b5d2000-06-03 14:57:40 +00001270 struct stat st;
1271 struct utmpx utx;
andre6bb92372000-06-19 08:20:03 +00001272 int fd, found=0;
1273
1274 /* Clear the time entries */
1275 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001276
1277 if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1278 log("wtmpx_get_entry: problem opening %s: %s",
1279 WTMPX_FILE, strerror(errno));
1280 return 0;
1281 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001282 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001283 log("wtmpx_get_entry: couldn't stat %s: %s",
Tim Ricecdb82942002-07-14 15:33:20 -07001284 WTMPX_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001285 close(fd);
1286 return 0;
1287 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001288
andre6bb92372000-06-19 08:20:03 +00001289 /* Seek to the start of the last struct utmpx */
Kevin Steves52172652001-10-02 00:29:00 +00001290 if (lseek(fd, -(off_t)sizeof(struct utmpx), SEEK_END) == -1 ) {
andre6bb92372000-06-19 08:20:03 +00001291 /* probably a newly rotated wtmpx file */
1292 close(fd);
1293 return 0;
1294 }
andre2ff7b5d2000-06-03 14:57:40 +00001295
andre6bb92372000-06-19 08:20:03 +00001296 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001297 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001298 log("wtmpx_get_entry: read of %s failed: %s",
1299 WTMPX_FILE, strerror(errno));
1300 close (fd);
1301 return 0;
1302 }
andre2ff7b5d2000-06-03 14:57:40 +00001303 /* Logouts are recorded as a blank username on a particular line.
1304 * So, we just need to find the username in struct utmpx */
andre6bb92372000-06-19 08:20:03 +00001305 if ( wtmpx_islogin(li, &utx) ) {
Tim Rice370e0ba2002-07-14 15:50:51 -07001306 found = 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001307# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001308 li->tv_sec = utx.ut_tv.tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +10001309# else
andre2ff7b5d2000-06-03 14:57:40 +00001310# ifdef HAVE_TIME_IN_UTMPX
1311 li->tv_sec = utx.ut_time;
1312# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001313# endif
Damien Miller1a132252000-06-13 21:23:17 +10001314 line_fullname(li->line, utx.ut_line, sizeof(li->line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001315# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001316 strlcpy(li->hostname, utx.ut_host,
1317 MIN_SIZEOF(li->hostname, utx.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001318# endif
andre6bb92372000-06-19 08:20:03 +00001319 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001320 }
Kevin Steves52172652001-10-02 00:29:00 +00001321 if (lseek(fd, -(off_t)(2 * sizeof(struct utmpx)), SEEK_CUR) == -1) {
andre2ff7b5d2000-06-03 14:57:40 +00001322 close (fd);
1323 return 0;
1324 }
andre6bb92372000-06-19 08:20:03 +00001325 }
1326
1327 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001328 return 1;
andre61e67252000-06-04 17:07:49 +00001329}
Damien Millerd5bf3072000-06-07 21:32:13 +10001330#endif /* USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001331
andre2ff7b5d2000-06-03 14:57:40 +00001332/**
andre61e67252000-06-04 17:07:49 +00001333 ** Low-level libutil login() functions
andre2ff7b5d2000-06-03 14:57:40 +00001334 **/
1335
1336#ifdef USE_LOGIN
andre2ff7b5d2000-06-03 14:57:40 +00001337static int
andre61e67252000-06-04 17:07:49 +00001338syslogin_perform_login(struct logininfo *li)
1339{
andre2ff7b5d2000-06-03 14:57:40 +00001340 struct utmp *ut;
1341
Damien Miller348c9b72000-08-15 10:01:22 +10001342 if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
andre2ff7b5d2000-06-03 14:57:40 +00001343 log("syslogin_perform_login: couldn't malloc()");
1344 return 0;
1345 }
1346 construct_utmp(li, ut);
1347 login(ut);
1348
1349 return 1;
andre61e67252000-06-04 17:07:49 +00001350}
1351
andre2ff7b5d2000-06-03 14:57:40 +00001352static int
andre61e67252000-06-04 17:07:49 +00001353syslogin_perform_logout(struct logininfo *li)
1354{
Damien Millerdd47aa22000-06-27 11:18:27 +10001355# ifdef HAVE_LOGOUT
andre2ff7b5d2000-06-03 14:57:40 +00001356 char line[8];
Kevin Stevesef4eea92001-02-05 12:42:17 +00001357
andre2ff7b5d2000-06-03 14:57:40 +00001358 (void)line_stripname(line, li->line, sizeof(line));
1359
1360 if (!logout(line)) {
1361 log("syslogin_perform_logout: logout() returned an error");
Damien Millerdd47aa22000-06-27 11:18:27 +10001362# ifdef HAVE_LOGWTMP
andre2ff7b5d2000-06-03 14:57:40 +00001363 } else {
1364 logwtmp(line, "", "");
Damien Millerdd47aa22000-06-27 11:18:27 +10001365# endif
Damien Miller9b6d4ab2000-07-02 08:43:18 +10001366 }
andre6bb92372000-06-19 08:20:03 +00001367 /* FIXME: (ATL - if the need arises) What to do if we have
1368 * login, but no logout? what if logout but no logwtmp? All
1369 * routines are in libutil so they should all be there,
1370 * but... */
Damien Millerdd47aa22000-06-27 11:18:27 +10001371# endif
andre2ff7b5d2000-06-03 14:57:40 +00001372 return 1;
andre61e67252000-06-04 17:07:49 +00001373}
andre2ff7b5d2000-06-03 14:57:40 +00001374
andre2ff7b5d2000-06-03 14:57:40 +00001375int
andre61e67252000-06-04 17:07:49 +00001376syslogin_write_entry(struct logininfo *li)
1377{
andre2ff7b5d2000-06-03 14:57:40 +00001378 switch (li->type) {
1379 case LTYPE_LOGIN:
1380 return syslogin_perform_login(li);
1381 case LTYPE_LOGOUT:
1382 return syslogin_perform_logout(li);
1383 default:
1384 log("syslogin_write_entry: Invalid type field");
1385 return 0;
1386 }
andre61e67252000-06-04 17:07:49 +00001387}
Damien Millerd5bf3072000-06-07 21:32:13 +10001388#endif /* USE_LOGIN */
andre2ff7b5d2000-06-03 14:57:40 +00001389
1390/* end of file log-syslogin.c */
1391
andre2ff7b5d2000-06-03 14:57:40 +00001392/**
andre61e67252000-06-04 17:07:49 +00001393 ** Low-level lastlog functions
andre2ff7b5d2000-06-03 14:57:40 +00001394 **/
1395
1396#ifdef USE_LASTLOG
Damien Millerdd47aa22000-06-27 11:18:27 +10001397#define LL_FILE 1
1398#define LL_DIR 2
1399#define LL_OTHER 3
andre2ff7b5d2000-06-03 14:57:40 +00001400
andre2ff7b5d2000-06-03 14:57:40 +00001401static void
andre61e67252000-06-04 17:07:49 +00001402lastlog_construct(struct logininfo *li, struct lastlog *last)
1403{
andre2ff7b5d2000-06-03 14:57:40 +00001404 /* clear the structure */
Damien Miller348c9b72000-08-15 10:01:22 +10001405 memset(last, '\0', sizeof(*last));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001406
Damien Millerdd47aa22000-06-27 11:18:27 +10001407 (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
andre6bb92372000-06-19 08:20:03 +00001408 strlcpy(last->ll_host, li->hostname,
1409 MIN_SIZEOF(last->ll_host, li->hostname));
andre2ff7b5d2000-06-03 14:57:40 +00001410 last->ll_time = li->tv_sec;
andre61e67252000-06-04 17:07:49 +00001411}
andre2ff7b5d2000-06-03 14:57:40 +00001412
andre2ff7b5d2000-06-03 14:57:40 +00001413static int
andre61e67252000-06-04 17:07:49 +00001414lastlog_filetype(char *filename)
1415{
andre2ff7b5d2000-06-03 14:57:40 +00001416 struct stat st;
1417
Damien Millerdd47aa22000-06-27 11:18:27 +10001418 if (stat(LASTLOG_FILE, &st) != 0) {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001419 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
Damien Millerdd47aa22000-06-27 11:18:27 +10001420 strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001421 return 0;
1422 }
andre2ff7b5d2000-06-03 14:57:40 +00001423 if (S_ISDIR(st.st_mode))
1424 return LL_DIR;
1425 else if (S_ISREG(st.st_mode))
1426 return LL_FILE;
1427 else
1428 return LL_OTHER;
andre61e67252000-06-04 17:07:49 +00001429}
andre2ff7b5d2000-06-03 14:57:40 +00001430
1431
1432/* open the file (using filemode) and seek to the login entry */
1433static int
andre61e67252000-06-04 17:07:49 +00001434lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1435{
andre2ff7b5d2000-06-03 14:57:40 +00001436 off_t offset;
1437 int type;
1438 char lastlog_file[1024];
1439
1440 type = lastlog_filetype(LASTLOG_FILE);
1441 switch (type) {
Damien Millerf8af08d2000-06-27 09:40:06 +10001442 case LL_FILE:
1443 strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1444 break;
1445 case LL_DIR:
1446 snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1447 LASTLOG_FILE, li->username);
1448 break;
1449 default:
1450 log("lastlog_openseek: %.100s is not a file or directory!",
1451 LASTLOG_FILE);
1452 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001453 }
andre2ff7b5d2000-06-03 14:57:40 +00001454
1455 *fd = open(lastlog_file, filemode);
1456 if ( *fd < 0) {
Damien Miller53c5d462000-06-28 00:50:50 +10001457 debug("lastlog_openseek: Couldn't open %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001458 lastlog_file, strerror(errno));
1459 return 0;
1460 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001461
Damien Millere477ef62000-08-15 10:21:17 +10001462 if (type == LL_FILE) {
1463 /* find this uid's offset in the lastlog file */
Kevin Steves52172652001-10-02 00:29:00 +00001464 offset = (off_t) ((long)li->uid * sizeof(struct lastlog));
andre2ff7b5d2000-06-03 14:57:40 +00001465
Damien Millere477ef62000-08-15 10:21:17 +10001466 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1467 log("lastlog_openseek: %s->lseek(): %s",
Kevin Stevesef4eea92001-02-05 12:42:17 +00001468 lastlog_file, strerror(errno));
Damien Millere477ef62000-08-15 10:21:17 +10001469 return 0;
1470 }
andre2ff7b5d2000-06-03 14:57:40 +00001471 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001472
andre2ff7b5d2000-06-03 14:57:40 +00001473 return 1;
andre61e67252000-06-04 17:07:49 +00001474}
andre2ff7b5d2000-06-03 14:57:40 +00001475
1476static int
andre61e67252000-06-04 17:07:49 +00001477lastlog_perform_login(struct logininfo *li)
1478{
andre2ff7b5d2000-06-03 14:57:40 +00001479 struct lastlog last;
1480 int fd;
1481
1482 /* create our struct lastlog */
1483 lastlog_construct(li, &last);
1484
Damien Millerc1132e72000-08-18 14:08:38 +10001485 if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1486 return(0);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001487
andre2ff7b5d2000-06-03 14:57:40 +00001488 /* write the entry */
Damien Millerc1132e72000-08-18 14:08:38 +10001489 if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1490 close(fd);
1491 log("lastlog_write_filemode: Error writing to %s: %s",
1492 LASTLOG_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001493 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001494 }
Damien Millerc1132e72000-08-18 14:08:38 +10001495
1496 close(fd);
1497 return 1;
andre61e67252000-06-04 17:07:49 +00001498}
andre2ff7b5d2000-06-03 14:57:40 +00001499
andre2ff7b5d2000-06-03 14:57:40 +00001500int
andre61e67252000-06-04 17:07:49 +00001501lastlog_write_entry(struct logininfo *li)
1502{
andre2ff7b5d2000-06-03 14:57:40 +00001503 switch(li->type) {
1504 case LTYPE_LOGIN:
1505 return lastlog_perform_login(li);
1506 default:
1507 log("lastlog_write_entry: Invalid type field");
1508 return 0;
1509 }
andre61e67252000-06-04 17:07:49 +00001510}
andre2ff7b5d2000-06-03 14:57:40 +00001511
andre2ff7b5d2000-06-03 14:57:40 +00001512static void
andre61e67252000-06-04 17:07:49 +00001513lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1514{
andre2ff7b5d2000-06-03 14:57:40 +00001515 line_fullname(li->line, last->ll_line, sizeof(li->line));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001516 strlcpy(li->hostname, last->ll_host,
andre6bb92372000-06-19 08:20:03 +00001517 MIN_SIZEOF(li->hostname, last->ll_host));
andre2ff7b5d2000-06-03 14:57:40 +00001518 li->tv_sec = last->ll_time;
andre61e67252000-06-04 17:07:49 +00001519}
andre2ff7b5d2000-06-03 14:57:40 +00001520
andre2ff7b5d2000-06-03 14:57:40 +00001521int
andre61e67252000-06-04 17:07:49 +00001522lastlog_get_entry(struct logininfo *li)
1523{
andre2ff7b5d2000-06-03 14:57:40 +00001524 struct lastlog last;
Damien Miller7df881d2003-01-07 16:46:58 +11001525 int fd, ret;
andre2ff7b5d2000-06-03 14:57:40 +00001526
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001527 if (!lastlog_openseek(li, &fd, O_RDONLY))
Damien Miller7df881d2003-01-07 16:46:58 +11001528 return (0);
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001529
Damien Miller7df881d2003-01-07 16:46:58 +11001530 ret = atomicio(read, fd, &last, sizeof(last));
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001531 close(fd);
1532
Damien Miller7df881d2003-01-07 16:46:58 +11001533 switch (ret) {
1534 case 0:
1535 memset(&last, '\0', sizeof(last));
1536 /* FALLTHRU */
1537 case sizeof(last):
1538 lastlog_populate_entry(li, &last);
1539 return (1);
1540 case -1:
1541 error("%s: Error reading from %s: %s", __func__,
1542 LASTLOG_FILE, strerror(errno));
1543 return (0);
1544 default:
1545 error("%s: Error reading from %s: Expecting %d, got %d",
1546 __func__, LASTLOG_FILE, sizeof(last), ret);
1547 return (0);
1548 }
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001549
Damien Miller7df881d2003-01-07 16:46:58 +11001550 /* NOTREACHED */
1551 return (0);
andre61e67252000-06-04 17:07:49 +00001552}
Damien Millerd5bf3072000-06-07 21:32:13 +10001553#endif /* USE_LASTLOG */