blob: 2d6bc69635a35258cf57e16d2374bc8076a7d6a2 [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.
andre2ff7b5d2000-06-03 14:57:40 +000015 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
Kevin Stevesef4eea92001-02-05 12:42:17 +000028/**
andre2ff7b5d2000-06-03 14:57:40 +000029 ** loginrec.c: platform-independent login recording and lastlog retrieval
30 **/
31
andre61e67252000-06-04 17:07:49 +000032/*
33 The new login code explained
34 ============================
35
36 This code attempts to provide a common interface to login recording
37 (utmp and friends) and last login time retrieval.
38
39 Its primary means of achieving this is to use 'struct logininfo', a
40 union of all the useful fields in the various different types of
41 system login record structures one finds on UNIX variants.
42
43 We depend on autoconf to define which recording methods are to be
44 used, and which fields are contained in the relevant data structures
45 on the local system. Many C preprocessor symbols affect which code
46 gets compiled here.
47
48 The code is designed to make it easy to modify a particular
49 recording method, without affecting other methods nor requiring so
50 many nested conditional compilation blocks as were commonplace in
51 the old code.
52
53 For login recording, we try to use the local system's libraries as
54 these are clearly most likely to work correctly. For utmp systems
55 this usually means login() and logout() or setutent() etc., probably
56 in libutil, along with logwtmp() etc. On these systems, we fall back
57 to writing the files directly if we have to, though this method
58 requires very thorough testing so we do not corrupt local auditing
59 information. These files and their access methods are very system
60 specific indeed.
Kevin Stevesef4eea92001-02-05 12:42:17 +000061
andre61e67252000-06-04 17:07:49 +000062 For utmpx systems, the corresponding library functions are
63 setutxent() etc. To the author's knowledge, all utmpx systems have
64 these library functions and so no direct write is attempted. If such
65 a system exists and needs support, direct analogues of the [uw]tmp
66 code should suffice.
67
68 Retrieving the time of last login ('lastlog') is in some ways even
69 more problemmatic than login recording. Some systems provide a
70 simple table of all users which we seek based on uid and retrieve a
71 relatively standard structure. Others record the same information in
72 a directory with a separate file, and others don't record the
73 information separately at all. For systems in the latter category,
74 we look backwards in the wtmp or wtmpx file for the last login entry
75 for our user. Naturally this is slower and on busy systems could
76 incur a significant performance penalty.
77
78 Calling the new code
79 --------------------
Kevin Stevesef4eea92001-02-05 12:42:17 +000080
andre61e67252000-06-04 17:07:49 +000081 In OpenSSH all login recording and retrieval is performed in
82 login.c. Here you'll find working examples. Also, in the logintest.c
83 program there are more examples.
84
85 Internal handler calling method
86 -------------------------------
Kevin Stevesef4eea92001-02-05 12:42:17 +000087
andre61e67252000-06-04 17:07:49 +000088 When a call is made to login_login() or login_logout(), both
89 routines set a struct logininfo flag defining which action (log in,
90 or log out) is to be taken. They both then call login_write(), which
91 calls whichever of the many structure-specific handlers autoconf
92 selects for the local system.
93
94 The handlers themselves handle system data structure specifics. Both
95 struct utmp and struct utmpx have utility functions (see
96 construct_utmp*()) to try to make it simpler to add extra systems
97 that introduce new features to either structure.
98
99 While it may seem terribly wasteful to replicate so much similar
100 code for each method, experience has shown that maintaining code to
101 write both struct utmp and utmpx in one function, whilst maintaining
102 support for all systems whether they have library support or not, is
103 a difficult and time-consuming task.
104
105 Lastlog support proceeds similarly. Functions login_get_lastlog()
106 (and its OpenSSH-tuned friend login_get_lastlog_time()) call
107 getlast_entry(), which tries one of three methods to find the last
108 login time. It uses local system lastlog support if it can,
109 otherwise it tries wtmp or wtmpx before giving up and returning 0,
110 meaning "tilt".
111
112 Maintenance
113 -----------
114
115 In many cases it's possible to tweak autoconf to select the correct
116 methods for a particular platform, either by improving the detection
117 code (best), or by presetting DISABLE_<method> or CONF_<method>_FILE
118 symbols for the platform.
119
120 Use logintest to check which symbols are defined before modifying
Tim Riceb89e6942001-10-29 18:50:39 -0800121 configure.ac and loginrec.c. (You have to build logintest yourself
andre61e67252000-06-04 17:07:49 +0000122 with 'make logintest' as it's not built by default.)
123
124 Otherwise, patches to the specific method(s) are very helpful!
Kevin Stevesef4eea92001-02-05 12:42:17 +0000125
andre61e67252000-06-04 17:07:49 +0000126*/
127
andre2ff7b5d2000-06-03 14:57:40 +0000128/**
129 ** TODO:
Damien Millere5192fa2000-08-29 14:30:37 +1100130 ** homegrown ttyslot()
andre61e67252000-06-04 17:07:49 +0000131 ** test, test, test
andre2ff7b5d2000-06-03 14:57:40 +0000132 **
133 ** Platform status:
134 ** ----------------
135 **
136 ** Known good:
Damien Millere5192fa2000-08-29 14:30:37 +1100137 ** Linux (Redhat 6.2, Debian)
138 ** Solaris
andre2ff7b5d2000-06-03 14:57:40 +0000139 ** HP-UX 10.20 (gcc only)
andre6bb92372000-06-19 08:20:03 +0000140 ** IRIX
Ben Lindstromdcca9812000-11-10 03:28:31 +0000141 ** NeXT - M68k/HPPA/Sparc (4.2/3.3)
andre2ff7b5d2000-06-03 14:57:40 +0000142 **
143 ** Testing required: Please send reports!
andre2ff7b5d2000-06-03 14:57:40 +0000144 ** NetBSD
145 ** HP-UX 11
andre60f3c982000-06-03 16:18:19 +0000146 ** AIX
andre2ff7b5d2000-06-03 14:57:40 +0000147 **
148 ** Platforms with known problems:
Damien Millere5192fa2000-08-29 14:30:37 +1100149 ** Some variants of Slackware Linux
andre2ff7b5d2000-06-03 14:57:40 +0000150 **
151 **/
152
153#include "includes.h"
154
andre2ff7b5d2000-06-03 14:57:40 +0000155#include "ssh.h"
156#include "xmalloc.h"
157#include "loginrec.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +0000158#include "log.h"
159#include "atomicio.h"
andre2ff7b5d2000-06-03 14:57:40 +0000160
Damien Miller0d8b7922003-05-10 23:42:12 +1000161RCSID("$Id: loginrec.c,v 1.51 2003/05/10 13:42:12 djm Exp $");
Ben Lindstromdcca9812000-11-10 03:28:31 +0000162
163#ifdef HAVE_UTIL_H
164# include <util.h>
165#endif
andre2ff7b5d2000-06-03 14:57:40 +0000166
Ben Lindstrome2fb8d32000-12-28 00:07:07 +0000167#ifdef HAVE_LIBUTIL_H
168# include <libutil.h>
169#endif
170
andre2ff7b5d2000-06-03 14:57:40 +0000171/**
172 ** prototypes for helper functions in this file
173 **/
174
175#if HAVE_UTMP_H
andre2ff7b5d2000-06-03 14:57:40 +0000176void set_utmp_time(struct logininfo *li, struct utmp *ut);
177void construct_utmp(struct logininfo *li, struct utmp *ut);
178#endif
179
180#ifdef HAVE_UTMPX_H
andre2ff7b5d2000-06-03 14:57:40 +0000181void set_utmpx_time(struct logininfo *li, struct utmpx *ut);
182void construct_utmpx(struct logininfo *li, struct utmpx *ut);
183#endif
184
185int utmp_write_entry(struct logininfo *li);
186int utmpx_write_entry(struct logininfo *li);
187int wtmp_write_entry(struct logininfo *li);
188int wtmpx_write_entry(struct logininfo *li);
189int lastlog_write_entry(struct logininfo *li);
190int syslogin_write_entry(struct logininfo *li);
191
192int getlast_entry(struct logininfo *li);
193int lastlog_get_entry(struct logininfo *li);
194int wtmp_get_entry(struct logininfo *li);
195int wtmpx_get_entry(struct logininfo *li);
196
andre6bb92372000-06-19 08:20:03 +0000197/* pick the shortest string */
198#define MIN_SIZEOF(s1,s2) ( sizeof(s1) < sizeof(s2) ? sizeof(s1) : sizeof(s2) )
199
andre2ff7b5d2000-06-03 14:57:40 +0000200/**
201 ** platform-independent login functions
202 **/
203
andre6bb92372000-06-19 08:20:03 +0000204/* login_login(struct logininfo *) -Record a login
Kevin Stevesef4eea92001-02-05 12:42:17 +0000205 *
andre6bb92372000-06-19 08:20:03 +0000206 * Call with a pointer to a struct logininfo initialised with
207 * login_init_entry() or login_alloc_entry()
208 *
209 * Returns:
210 * >0 if successful
211 * 0 on failure (will use OpenSSH's logging facilities for diagnostics)
212 */
andre61e67252000-06-04 17:07:49 +0000213int
214login_login (struct logininfo *li)
215{
216 li->type = LTYPE_LOGIN;
217 return login_write(li);
218}
219
220
andre6bb92372000-06-19 08:20:03 +0000221/* login_logout(struct logininfo *) - Record a logout
222 *
223 * Call as with login_login()
224 *
225 * Returns:
226 * >0 if successful
227 * 0 on failure (will use OpenSSH's logging facilities for diagnostics)
228 */
andre61e67252000-06-04 17:07:49 +0000229int
230login_logout(struct logininfo *li)
231{
232 li->type = LTYPE_LOGOUT;
233 return login_write(li);
234}
235
andre6bb92372000-06-19 08:20:03 +0000236/* login_get_lastlog_time(int) - Retrieve the last login time
237 *
238 * Retrieve the last login time for the given uid. Will try to use the
239 * system lastlog facilities if they are available, but will fall back
240 * to looking in wtmp/wtmpx if necessary
241 *
242 * Returns:
243 * 0 on failure, or if user has never logged in
244 * Time in seconds from the epoch if successful
245 *
246 * Useful preprocessor symbols:
247 * DISABLE_LASTLOG: If set, *never* even try to retrieve lastlog
248 * info
249 * USE_LASTLOG: If set, indicates the presence of system lastlog
250 * facilities. If this and DISABLE_LASTLOG are not set,
251 * try to retrieve lastlog information from wtmp/wtmpx.
252 */
andre61e67252000-06-04 17:07:49 +0000253unsigned int
254login_get_lastlog_time(const int uid)
255{
256 struct logininfo li;
257
andre6bb92372000-06-19 08:20:03 +0000258 if (login_get_lastlog(&li, uid))
259 return li.tv_sec;
260 else
261 return 0;
andre61e67252000-06-04 17:07:49 +0000262}
263
andre6bb92372000-06-19 08:20:03 +0000264/* login_get_lastlog(struct logininfo *, int) - Retrieve a lastlog entry
265 *
266 * Retrieve a logininfo structure populated (only partially) with
267 * information from the system lastlog data, or from wtmp/wtmpx if no
268 * system lastlog information exists.
269 *
270 * Note this routine must be given a pre-allocated logininfo.
271 *
272 * Returns:
273 * >0: A pointer to your struct logininfo if successful
274 * 0 on failure (will use OpenSSH's logging facilities for diagnostics)
275 *
276 */
andre61e67252000-06-04 17:07:49 +0000277struct logininfo *
278login_get_lastlog(struct logininfo *li, const int uid)
279{
andre6bb92372000-06-19 08:20:03 +0000280 struct passwd *pw;
andre6bb92372000-06-19 08:20:03 +0000281
Damien Miller348c9b72000-08-15 10:01:22 +1000282 memset(li, '\0', sizeof(*li));
andre61e67252000-06-04 17:07:49 +0000283 li->uid = uid;
andre6bb92372000-06-19 08:20:03 +0000284
Kevin Stevesef4eea92001-02-05 12:42:17 +0000285 /*
Damien Miller53c5d462000-06-28 00:50:50 +1000286 * If we don't have a 'real' lastlog, we need the username to
andre6bb92372000-06-19 08:20:03 +0000287 * reliably search wtmp(x) for the last login (see
Kevin Stevesef4eea92001-02-05 12:42:17 +0000288 * wtmp_get_entry().)
Damien Miller53c5d462000-06-28 00:50:50 +1000289 */
andre6bb92372000-06-19 08:20:03 +0000290 pw = getpwuid(uid);
Damien Millerdd47aa22000-06-27 11:18:27 +1000291 if (pw == NULL)
292 fatal("login_get_lastlog: Cannot find account for uid %i", uid);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000293
andre98cabe02000-06-19 09:11:30 +0000294 /* No MIN_SIZEOF here - we absolutely *must not* truncate the
Kevin Stevesef4eea92001-02-05 12:42:17 +0000295 * username */
Damien Millerf8af08d2000-06-27 09:40:06 +1000296 strlcpy(li->username, pw->pw_name, sizeof(li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000297
andre61e67252000-06-04 17:07:49 +0000298 if (getlast_entry(li))
299 return li;
300 else
Damien Millerdd47aa22000-06-27 11:18:27 +1000301 return NULL;
andre61e67252000-06-04 17:07:49 +0000302}
303
304
andre6bb92372000-06-19 08:20:03 +0000305/* login_alloc_entry(int, char*, char*, char*) - Allocate and initialise
Kevin Stevesef4eea92001-02-05 12:42:17 +0000306 * a logininfo structure
307 *
andre6bb92372000-06-19 08:20:03 +0000308 * This function creates a new struct logininfo, a data structure
309 * meant to carry the information required to portably record login info.
310 *
311 * Returns a pointer to a newly created struct logininfo. If memory
312 * allocation fails, the program halts.
313 */
andre61e67252000-06-04 17:07:49 +0000314struct
315logininfo *login_alloc_entry(int pid, const char *username,
316 const char *hostname, const char *line)
317{
andre2ff7b5d2000-06-03 14:57:40 +0000318 struct logininfo *newli;
319
Damien Miller348c9b72000-08-15 10:01:22 +1000320 newli = (struct logininfo *) xmalloc (sizeof(*newli));
andre61e67252000-06-04 17:07:49 +0000321 (void)login_init_entry(newli, pid, username, hostname, line);
322 return newli;
323}
andre2ff7b5d2000-06-03 14:57:40 +0000324
325
andre6bb92372000-06-19 08:20:03 +0000326/* login_free_entry(struct logininfo *) - free struct memory */
andre61e67252000-06-04 17:07:49 +0000327void
328login_free_entry(struct logininfo *li)
329{
330 xfree(li);
331}
332
andre2ff7b5d2000-06-03 14:57:40 +0000333
andre6bb92372000-06-19 08:20:03 +0000334/* login_init_entry(struct logininfo *, int, char*, char*, char*)
335 * - initialise a struct logininfo
Kevin Stevesef4eea92001-02-05 12:42:17 +0000336 *
andre6bb92372000-06-19 08:20:03 +0000337 * Populates a new struct logininfo, a data structure meant to carry
338 * the information required to portably record login info.
339 *
340 * Returns: 1
341 */
andre61e67252000-06-04 17:07:49 +0000342int
Kevin Stevesef4eea92001-02-05 12:42:17 +0000343login_init_entry(struct logininfo *li, int pid, const char *username,
andre61e67252000-06-04 17:07:49 +0000344 const char *hostname, const char *line)
345{
Damien Millerf8af08d2000-06-27 09:40:06 +1000346 struct passwd *pw;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000347
Damien Miller348c9b72000-08-15 10:01:22 +1000348 memset(li, 0, sizeof(*li));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000349
andre61e67252000-06-04 17:07:49 +0000350 li->pid = pid;
Damien Millerf8af08d2000-06-27 09:40:06 +1000351
andre2ff7b5d2000-06-03 14:57:40 +0000352 /* set the line information */
andre61e67252000-06-04 17:07:49 +0000353 if (line)
andre2ff7b5d2000-06-03 14:57:40 +0000354 line_fullname(li->line, line, sizeof(li->line));
andre2ff7b5d2000-06-03 14:57:40 +0000355
Damien Millerf8af08d2000-06-27 09:40:06 +1000356 if (username) {
andre2ff7b5d2000-06-03 14:57:40 +0000357 strlcpy(li->username, username, sizeof(li->username));
Damien Millerf8af08d2000-06-27 09:40:06 +1000358 pw = getpwnam(li->username);
359 if (pw == NULL)
360 fatal("login_init_entry: Cannot find user \"%s\"", li->username);
361 li->uid = pw->pw_uid;
362 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000363
andre61e67252000-06-04 17:07:49 +0000364 if (hostname)
andre2ff7b5d2000-06-03 14:57:40 +0000365 strlcpy(li->hostname, hostname, sizeof(li->hostname));
Damien Millerf8af08d2000-06-27 09:40:06 +1000366
andre61e67252000-06-04 17:07:49 +0000367 return 1;
andre2ff7b5d2000-06-03 14:57:40 +0000368}
369
andre6bb92372000-06-19 08:20:03 +0000370/* login_set_current_time(struct logininfo *) - set the current time
371 *
372 * Set the current time in a logininfo structure. This function is
373 * meant to eliminate the need to deal with system dependencies for
374 * time handling.
375 */
andre2ff7b5d2000-06-03 14:57:40 +0000376void
andre61e67252000-06-04 17:07:49 +0000377login_set_current_time(struct logininfo *li)
378{
andre2ff7b5d2000-06-03 14:57:40 +0000379 struct timeval tv;
380
381 gettimeofday(&tv, NULL);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000382
Damien Millerf8af08d2000-06-27 09:40:06 +1000383 li->tv_sec = tv.tv_sec;
384 li->tv_usec = tv.tv_usec;
andre2ff7b5d2000-06-03 14:57:40 +0000385}
386
andre61e67252000-06-04 17:07:49 +0000387/* copy a sockaddr_* into our logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000388void
andre61e67252000-06-04 17:07:49 +0000389login_set_addr(struct logininfo *li, const struct sockaddr *sa,
390 const unsigned int sa_size)
391{
392 unsigned int bufsize = sa_size;
393
394 /* make sure we don't overrun our union */
395 if (sizeof(li->hostaddr) < sa_size)
396 bufsize = sizeof(li->hostaddr);
397
398 memcpy((void *)&(li->hostaddr.sa), (const void *)sa, bufsize);
andre2ff7b5d2000-06-03 14:57:40 +0000399}
400
andre2ff7b5d2000-06-03 14:57:40 +0000401
andre61e67252000-06-04 17:07:49 +0000402/**
403 ** login_write: Call low-level recording functions based on autoconf
404 ** results
405 **/
andre2ff7b5d2000-06-03 14:57:40 +0000406int
andre61e67252000-06-04 17:07:49 +0000407login_write (struct logininfo *li)
408{
Damien Millerbac2d8a2000-09-05 16:13:06 +1100409#ifndef HAVE_CYGWIN
andre2ff7b5d2000-06-03 14:57:40 +0000410 if ((int)geteuid() != 0) {
Damien Miller996acd22003-04-09 20:59:48 +1000411 logit("Attempt to write login records by non-root user (aborting)");
andre2ff7b5d2000-06-03 14:57:40 +0000412 return 1;
413 }
Damien Millerbac2d8a2000-09-05 16:13:06 +1100414#endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000415
andre2ff7b5d2000-06-03 14:57:40 +0000416 /* set the timestamp */
417 login_set_current_time(li);
418#ifdef USE_LOGIN
419 syslogin_write_entry(li);
420#endif
421#ifdef USE_LASTLOG
422 if (li->type == LTYPE_LOGIN) {
423 lastlog_write_entry(li);
424 }
425#endif
426#ifdef USE_UTMP
427 utmp_write_entry(li);
428#endif
429#ifdef USE_WTMP
430 wtmp_write_entry(li);
431#endif
432#ifdef USE_UTMPX
433 utmpx_write_entry(li);
434#endif
435#ifdef USE_WTMPX
436 wtmpx_write_entry(li);
437#endif
438 return 0;
439}
440
Ben Lindstrom97c677d2001-05-08 20:33:05 +0000441#ifdef LOGIN_NEEDS_UTMPX
442int
443login_utmp_only(struct logininfo *li)
444{
445 li->type = LTYPE_LOGIN;
Ben Lindstrom9197c592001-10-26 15:56:55 +0000446 login_set_current_time(li);
Ben Lindstrom97c677d2001-05-08 20:33:05 +0000447# ifdef USE_UTMP
448 utmp_write_entry(li);
449# endif
450# ifdef USE_WTMP
451 wtmp_write_entry(li);
452# endif
453# ifdef USE_UTMPX
454 utmpx_write_entry(li);
455# endif
456# ifdef USE_WTMPX
457 wtmpx_write_entry(li);
458# endif
459 return 0;
460}
461#endif
462
andre2ff7b5d2000-06-03 14:57:40 +0000463/**
andre61e67252000-06-04 17:07:49 +0000464 ** getlast_entry: Call low-level functions to retrieve the last login
465 ** time.
andre2ff7b5d2000-06-03 14:57:40 +0000466 **/
467
andre61e67252000-06-04 17:07:49 +0000468/* take the uid in li and return the last login time */
469int
470getlast_entry(struct logininfo *li)
471{
472#ifdef USE_LASTLOG
Damien Miller53c5d462000-06-28 00:50:50 +1000473 return(lastlog_get_entry(li));
Damien Millerdd47aa22000-06-27 11:18:27 +1000474#else /* !USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000475
Damien Millerdd47aa22000-06-27 11:18:27 +1000476#ifdef DISABLE_LASTLOG
Kevin Stevesef4eea92001-02-05 12:42:17 +0000477 /* On some systems we shouldn't even try to obtain last login
andreecaabf12000-06-12 22:21:44 +0000478 * time, e.g. AIX */
479 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000480# else /* DISABLE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000481 /* Try to retrieve the last login time from wtmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000482# if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
andre61e67252000-06-04 17:07:49 +0000483 /* retrieve last login time from utmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000484 return (wtmp_get_entry(li));
485# else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
andre61e67252000-06-04 17:07:49 +0000486 /* If wtmp isn't available, try wtmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000487# if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
andre61e67252000-06-04 17:07:49 +0000488 /* retrieve last login time from utmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000489 return (wtmpx_get_entry(li));
490# else
andre61e67252000-06-04 17:07:49 +0000491 /* Give up: No means of retrieving last login time */
492 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000493# endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
494# endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000495# endif /* DISABLE_LASTLOG */
Damien Millerdd47aa22000-06-27 11:18:27 +1000496#endif /* USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000497}
498
499
500
andre2ff7b5d2000-06-03 14:57:40 +0000501/*
andre61e67252000-06-04 17:07:49 +0000502 * 'line' string utility functions
503 *
504 * These functions process the 'line' string into one of three forms:
505 *
andre2ff7b5d2000-06-03 14:57:40 +0000506 * 1. The full filename (including '/dev')
507 * 2. The stripped name (excluding '/dev')
andre61e67252000-06-04 17:07:49 +0000508 * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
509 * /dev/pts/1 -> ts/1 )
andre2ff7b5d2000-06-03 14:57:40 +0000510 *
511 * Form 3 is used on some systems to identify a .tmp.? entry when
512 * attempting to remove it. Typically both addition and removal is
andre61e67252000-06-04 17:07:49 +0000513 * performed by one application - say, sshd - so as long as the choice
514 * uniquely identifies a terminal it's ok.
andre2ff7b5d2000-06-03 14:57:40 +0000515 */
516
517
andre61e67252000-06-04 17:07:49 +0000518/* line_fullname(): add the leading '/dev/' if it doesn't exist make
519 * sure dst has enough space, if not just copy src (ugh) */
andre2ff7b5d2000-06-03 14:57:40 +0000520char *
andre61e67252000-06-04 17:07:49 +0000521line_fullname(char *dst, const char *src, int dstsize)
522{
andre2ff7b5d2000-06-03 14:57:40 +0000523 memset(dst, '\0', dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100524 if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
andre2ff7b5d2000-06-03 14:57:40 +0000525 strlcpy(dst, src, dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100526 } else {
Damien Miller1a132252000-06-13 21:23:17 +1000527 strlcpy(dst, "/dev/", dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000528 strlcat(dst, src, dstsize);
529 }
530 return dst;
531}
532
andre61e67252000-06-04 17:07:49 +0000533/* line_stripname(): strip the leading '/dev' if it exists, return dst */
andre2ff7b5d2000-06-03 14:57:40 +0000534char *
andre61e67252000-06-04 17:07:49 +0000535line_stripname(char *dst, const char *src, int dstsize)
536{
andre2ff7b5d2000-06-03 14:57:40 +0000537 memset(dst, '\0', dstsize);
538 if (strncmp(src, "/dev/", 5) == 0)
Damien Millerf5a81472000-09-30 21:34:44 +1100539 strlcpy(dst, src + 5, dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000540 else
541 strlcpy(dst, src, dstsize);
542 return dst;
andre61e67252000-06-04 17:07:49 +0000543}
544
andre61e67252000-06-04 17:07:49 +0000545/* line_abbrevname(): Return the abbreviated (usually four-character)
546 * form of the line (Just use the last <dstsize> characters of the
547 * full name.)
548 *
549 * NOTE: use strncpy because we do NOT necessarily want zero
550 * termination */
andre2ff7b5d2000-06-03 14:57:40 +0000551char *
Kevin Stevesef4eea92001-02-05 12:42:17 +0000552line_abbrevname(char *dst, const char *src, int dstsize)
Damien Millerdd47aa22000-06-27 11:18:27 +1000553{
554 size_t len;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000555
andre2ff7b5d2000-06-03 14:57:40 +0000556 memset(dst, '\0', dstsize);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000557
Damien Miller8e81ed32000-07-01 13:17:42 +1000558 /* Always skip prefix if present */
559 if (strncmp(src, "/dev/", 5) == 0)
560 src += 5;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000561
Damien Millerf1b9d112002-04-23 23:09:19 +1000562#ifdef WITH_ABBREV_NO_TTY
563 if (strncmp(src, "tty", 3) == 0)
564 src += 3;
565#endif
566
Damien Millerdd47aa22000-06-27 11:18:27 +1000567 len = strlen(src);
568
Damien Miller8e81ed32000-07-01 13:17:42 +1000569 if (len > 0) {
570 if (((int)len - dstsize) > 0)
571 src += ((int)len - dstsize);
572
573 /* note: _don't_ change this to strlcpy */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000574 strncpy(dst, src, (size_t)dstsize);
Damien Millerdd47aa22000-06-27 11:18:27 +1000575 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000576
andre2ff7b5d2000-06-03 14:57:40 +0000577 return dst;
578}
579
andre2ff7b5d2000-06-03 14:57:40 +0000580/**
581 ** utmp utility functions
andre61e67252000-06-04 17:07:49 +0000582 **
583 ** These functions manipulate struct utmp, taking system differences
584 ** into account.
andre2ff7b5d2000-06-03 14:57:40 +0000585 **/
586
587#if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
588
andre2ff7b5d2000-06-03 14:57:40 +0000589/* build the utmp structure */
590void
andre61e67252000-06-04 17:07:49 +0000591set_utmp_time(struct logininfo *li, struct utmp *ut)
592{
Damien Millerdd47aa22000-06-27 11:18:27 +1000593# ifdef HAVE_TV_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000594 ut->ut_tv.tv_sec = li->tv_sec;
595 ut->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000596# else
andre2ff7b5d2000-06-03 14:57:40 +0000597# ifdef HAVE_TIME_IN_UTMP
598 ut->ut_time = li->tv_sec;
599# endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000600# endif
andre2ff7b5d2000-06-03 14:57:40 +0000601}
602
603void
604construct_utmp(struct logininfo *li,
andre61e67252000-06-04 17:07:49 +0000605 struct utmp *ut)
606{
Damien Miller02e16ad2003-01-03 14:42:27 +1100607# ifdef HAVE_ADDR_V6_IN_UTMP
608 struct sockaddr_in6 *sa6;
609# endif
Damien Miller348c9b72000-08-15 10:01:22 +1000610 memset(ut, '\0', sizeof(*ut));
andre6bb92372000-06-19 08:20:03 +0000611
612 /* First fill out fields used for both logins and logouts */
613
Damien Millerdd47aa22000-06-27 11:18:27 +1000614# ifdef HAVE_ID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000615 line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000616# endif
andre2ff7b5d2000-06-03 14:57:40 +0000617
Damien Millerdd47aa22000-06-27 11:18:27 +1000618# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000619 /* This is done here to keep utmp constants out of struct logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000620 switch (li->type) {
621 case LTYPE_LOGIN:
622 ut->ut_type = USER_PROCESS;
Tim Rice81ed5182002-09-25 17:38:46 -0700623#ifdef _UNICOS
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000624 cray_set_tmpdir(ut);
625#endif
andre2ff7b5d2000-06-03 14:57:40 +0000626 break;
627 case LTYPE_LOGOUT:
628 ut->ut_type = DEAD_PROCESS;
Tim Rice81ed5182002-09-25 17:38:46 -0700629#ifdef _UNICOS
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000630 cray_retain_utmp(ut, li->pid);
631#endif
andre2ff7b5d2000-06-03 14:57:40 +0000632 break;
633 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000634# endif
andre6bb92372000-06-19 08:20:03 +0000635 set_utmp_time(li, ut);
andre2ff7b5d2000-06-03 14:57:40 +0000636
andre6bb92372000-06-19 08:20:03 +0000637 line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000638
639# ifdef HAVE_PID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000640 ut->ut_pid = li->pid;
Damien Millerdd47aa22000-06-27 11:18:27 +1000641# endif
andre6bb92372000-06-19 08:20:03 +0000642
643 /* If we're logging out, leave all other fields blank */
644 if (li->type == LTYPE_LOGOUT)
645 return;
646
Damien Millerdd47aa22000-06-27 11:18:27 +1000647 /*
648 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000649 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000650 */
andre6bb92372000-06-19 08:20:03 +0000651
652 /* Use strncpy because we don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000653 strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000654# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000655 strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000656# endif
657# ifdef HAVE_ADDR_IN_UTMP
andre61e67252000-06-04 17:07:49 +0000658 /* this is just a 32-bit IP address */
659 if (li->hostaddr.sa.sa_family == AF_INET)
660 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000661# endif
Damien Miller02e16ad2003-01-03 14:42:27 +1100662# ifdef HAVE_ADDR_V6_IN_UTMP
663 /* this is just a 128-bit IPv6 address */
664 if (li->hostaddr.sa.sa_family == AF_INET6) {
665 sa6 = ((struct sockaddr_in6 *)&li->hostaddr.sa);
666 memcpy(ut->ut_addr_v6, sa6->sin6_addr.s6_addr, 16);
667 if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr)) {
668 ut->ut_addr_v6[0] = ut->ut_addr_v6[3];
669 ut->ut_addr_v6[1] = 0;
670 ut->ut_addr_v6[2] = 0;
671 ut->ut_addr_v6[3] = 0;
672 }
673 }
674# endif
andre61e67252000-06-04 17:07:49 +0000675}
Damien Millerdd47aa22000-06-27 11:18:27 +1000676#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
andre61e67252000-06-04 17:07:49 +0000677
andre2ff7b5d2000-06-03 14:57:40 +0000678/**
679 ** utmpx utility functions
andre61e67252000-06-04 17:07:49 +0000680 **
681 ** These functions manipulate struct utmpx, accounting for system
682 ** variations.
andre2ff7b5d2000-06-03 14:57:40 +0000683 **/
684
685#if defined(USE_UTMPX) || defined (USE_WTMPX)
andre2ff7b5d2000-06-03 14:57:40 +0000686/* build the utmpx structure */
687void
andre61e67252000-06-04 17:07:49 +0000688set_utmpx_time(struct logininfo *li, struct utmpx *utx)
689{
Damien Millerdd47aa22000-06-27 11:18:27 +1000690# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000691 utx->ut_tv.tv_sec = li->tv_sec;
692 utx->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000693# else /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000694# ifdef HAVE_TIME_IN_UTMPX
695 utx->ut_time = li->tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000696# endif /* HAVE_TIME_IN_UTMPX */
697# endif /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000698}
699
andre61e67252000-06-04 17:07:49 +0000700void
701construct_utmpx(struct logininfo *li, struct utmpx *utx)
702{
Damien Miller02e16ad2003-01-03 14:42:27 +1100703# ifdef HAVE_ADDR_V6_IN_UTMP
704 struct sockaddr_in6 *sa6;
705# endif
Damien Miller348c9b72000-08-15 10:01:22 +1000706 memset(utx, '\0', sizeof(*utx));
Damien Miller8e81ed32000-07-01 13:17:42 +1000707# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000708 line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
Damien Miller8e81ed32000-07-01 13:17:42 +1000709# endif
andre2ff7b5d2000-06-03 14:57:40 +0000710
711 /* this is done here to keep utmp constants out of loginrec.h */
712 switch (li->type) {
713 case LTYPE_LOGIN:
714 utx->ut_type = USER_PROCESS;
715 break;
716 case LTYPE_LOGOUT:
717 utx->ut_type = DEAD_PROCESS;
718 break;
719 }
andre2ff7b5d2000-06-03 14:57:40 +0000720 line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
andre2ff7b5d2000-06-03 14:57:40 +0000721 set_utmpx_time(li, utx);
andre6bb92372000-06-19 08:20:03 +0000722 utx->ut_pid = li->pid;
Tim Ricee06ae4a2002-02-24 17:56:46 -0800723 /* strncpy(): Don't necessarily want null termination */
724 strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
andre6bb92372000-06-19 08:20:03 +0000725
726 if (li->type == LTYPE_LOGOUT)
727 return;
728
Damien Millerdd47aa22000-06-27 11:18:27 +1000729 /*
730 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000731 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000732 */
andre6bb92372000-06-19 08:20:03 +0000733
Damien Millerdd47aa22000-06-27 11:18:27 +1000734# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000735 strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000736# endif
737# ifdef HAVE_ADDR_IN_UTMPX
Damien Millerd6f204d2000-09-23 13:57:27 +1100738 /* this is just a 32-bit IP address */
739 if (li->hostaddr.sa.sa_family == AF_INET)
740 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Damien Millerdd47aa22000-06-27 11:18:27 +1000741# endif
Damien Miller02e16ad2003-01-03 14:42:27 +1100742# ifdef HAVE_ADDR_V6_IN_UTMP
743 /* this is just a 128-bit IPv6 address */
744 if (li->hostaddr.sa.sa_family == AF_INET6) {
745 sa6 = ((struct sockaddr_in6 *)&li->hostaddr.sa);
746 memcpy(ut->ut_addr_v6, sa6->sin6_addr.s6_addr, 16);
747 if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr)) {
748 ut->ut_addr_v6[0] = ut->ut_addr_v6[3];
749 ut->ut_addr_v6[1] = 0;
750 ut->ut_addr_v6[2] = 0;
751 ut->ut_addr_v6[3] = 0;
752 }
753 }
754# endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000755# ifdef HAVE_SYSLEN_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000756 /* ut_syslen is the length of the utx_host string */
757 utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +1000758# endif
andre61e67252000-06-04 17:07:49 +0000759}
Damien Millerdd47aa22000-06-27 11:18:27 +1000760#endif /* USE_UTMPX || USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000761
762/**
andre61e67252000-06-04 17:07:49 +0000763 ** Low-level utmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000764 **/
765
766/* FIXME: (ATL) utmp_write_direct needs testing */
andre2ff7b5d2000-06-03 14:57:40 +0000767#ifdef USE_UTMP
768
andre2ff7b5d2000-06-03 14:57:40 +0000769/* if we can, use pututline() etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000770# if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
771 defined(HAVE_PUTUTLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000772# define UTMP_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000773# endif
andre2ff7b5d2000-06-03 14:57:40 +0000774
775
776/* write a utmp entry with the system's help (pututline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000777# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000778static int
andre61e67252000-06-04 17:07:49 +0000779utmp_write_library(struct logininfo *li, struct utmp *ut)
780{
andre2ff7b5d2000-06-03 14:57:40 +0000781 setutent();
782 pututline(ut);
783
Damien Millerdd47aa22000-06-27 11:18:27 +1000784# ifdef HAVE_ENDUTENT
andre2ff7b5d2000-06-03 14:57:40 +0000785 endutent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000786# endif
andre2ff7b5d2000-06-03 14:57:40 +0000787 return 1;
andre61e67252000-06-04 17:07:49 +0000788}
Damien Millerdd47aa22000-06-27 11:18:27 +1000789# else /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000790
791/* write a utmp entry direct to the file */
andre61e67252000-06-04 17:07:49 +0000792/* This is a slightly modification of code in OpenBSD's login.c */
andre2ff7b5d2000-06-03 14:57:40 +0000793static int
andre61e67252000-06-04 17:07:49 +0000794utmp_write_direct(struct logininfo *li, struct utmp *ut)
795{
andre2ff7b5d2000-06-03 14:57:40 +0000796 struct utmp old_ut;
797 register int fd;
798 int tty;
799
andre6bb92372000-06-19 08:20:03 +0000800 /* FIXME: (ATL) ttyslot() needs local implementation */
Damien Miller348c9b72000-08-15 10:01:22 +1000801
Damien Millere5192fa2000-08-29 14:30:37 +1100802#if defined(HAVE_GETTTYENT)
Damien Miller348c9b72000-08-15 10:01:22 +1000803 register struct ttyent *ty;
804
805 tty=0;
806
807 setttyent();
808 while ((struct ttyent *)0 != (ty = getttyent())) {
809 tty++;
810 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
811 break;
812 }
813 endttyent();
814
815 if((struct ttyent *)0 == ty) {
Damien Miller996acd22003-04-09 20:59:48 +1000816 logit("utmp_write_entry: tty not found");
Damien Miller348c9b72000-08-15 10:01:22 +1000817 return(1);
818 }
819#else /* FIXME */
820
andre2ff7b5d2000-06-03 14:57:40 +0000821 tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
822
Damien Millere5192fa2000-08-29 14:30:37 +1100823#endif /* HAVE_GETTTYENT */
Damien Miller348c9b72000-08-15 10:01:22 +1000824
andre2ff7b5d2000-06-03 14:57:40 +0000825 if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
826 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
827 /*
828 * Prevent luser from zero'ing out ut_host.
829 * If the new ut_line is empty but the old one is not
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000830 * and ut_line and ut_name match, preserve the old ut_line.
andre2ff7b5d2000-06-03 14:57:40 +0000831 */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000832 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
833 (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
834 (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000835 (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
andre2ff7b5d2000-06-03 14:57:40 +0000836 (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
Damien Miller53c5d462000-06-28 00:50:50 +1000837 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000838
andre2ff7b5d2000-06-03 14:57:40 +0000839 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
Damien Miller36ccb5c2000-08-09 16:34:27 +1000840 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
Damien Miller996acd22003-04-09 20:59:48 +1000841 logit("utmp_write_direct: error writing %s: %s",
andre6bb92372000-06-19 08:20:03 +0000842 UTMP_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000843
andre2ff7b5d2000-06-03 14:57:40 +0000844 (void)close(fd);
845 return 1;
Damien Miller53c5d462000-06-28 00:50:50 +1000846 } else {
andre2ff7b5d2000-06-03 14:57:40 +0000847 return 0;
Damien Miller53c5d462000-06-28 00:50:50 +1000848 }
andre61e67252000-06-04 17:07:49 +0000849}
Damien Millerdd47aa22000-06-27 11:18:27 +1000850# endif /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000851
852static int
andre61e67252000-06-04 17:07:49 +0000853utmp_perform_login(struct logininfo *li)
854{
andre2ff7b5d2000-06-03 14:57:40 +0000855 struct utmp ut;
856
857 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000858# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000859 if (!utmp_write_library(li, &ut)) {
Damien Miller996acd22003-04-09 20:59:48 +1000860 logit("utmp_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000861 return 0;
862 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000863# else
andre2ff7b5d2000-06-03 14:57:40 +0000864 if (!utmp_write_direct(li, &ut)) {
Damien Miller996acd22003-04-09 20:59:48 +1000865 logit("utmp_perform_login: utmp_write_direct() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000866 return 0;
867 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000868# endif
andre2ff7b5d2000-06-03 14:57:40 +0000869 return 1;
andre61e67252000-06-04 17:07:49 +0000870}
andre2ff7b5d2000-06-03 14:57:40 +0000871
872
873static int
andre61e67252000-06-04 17:07:49 +0000874utmp_perform_logout(struct logininfo *li)
875{
andre2ff7b5d2000-06-03 14:57:40 +0000876 struct utmp ut;
877
andre6bb92372000-06-19 08:20:03 +0000878 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000879# ifdef UTMP_USE_LIBRARY
andre6bb92372000-06-19 08:20:03 +0000880 if (!utmp_write_library(li, &ut)) {
Damien Miller996acd22003-04-09 20:59:48 +1000881 logit("utmp_perform_logout: utmp_write_library() failed");
andre6bb92372000-06-19 08:20:03 +0000882 return 0;
883 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000884# else
andre6bb92372000-06-19 08:20:03 +0000885 if (!utmp_write_direct(li, &ut)) {
Damien Miller996acd22003-04-09 20:59:48 +1000886 logit("utmp_perform_logout: utmp_write_direct() failed");
andre6bb92372000-06-19 08:20:03 +0000887 return 0;
888 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000889# endif
andre2ff7b5d2000-06-03 14:57:40 +0000890 return 1;
andre61e67252000-06-04 17:07:49 +0000891}
andre2ff7b5d2000-06-03 14:57:40 +0000892
893
894int
andre61e67252000-06-04 17:07:49 +0000895utmp_write_entry(struct logininfo *li)
896{
andre2ff7b5d2000-06-03 14:57:40 +0000897 switch(li->type) {
898 case LTYPE_LOGIN:
899 return utmp_perform_login(li);
900
901 case LTYPE_LOGOUT:
902 return utmp_perform_logout(li);
903
904 default:
Damien Miller996acd22003-04-09 20:59:48 +1000905 logit("utmp_write_entry: invalid type field");
andre2ff7b5d2000-06-03 14:57:40 +0000906 return 0;
907 }
andre61e67252000-06-04 17:07:49 +0000908}
Damien Millerdd47aa22000-06-27 11:18:27 +1000909#endif /* USE_UTMP */
andre2ff7b5d2000-06-03 14:57:40 +0000910
911
912/**
andre61e67252000-06-04 17:07:49 +0000913 ** Low-level utmpx functions
andre2ff7b5d2000-06-03 14:57:40 +0000914 **/
915
916/* not much point if we don't want utmpx entries */
917#ifdef USE_UTMPX
918
andre2ff7b5d2000-06-03 14:57:40 +0000919/* if we have the wherewithall, use pututxline etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000920# if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
921 defined(HAVE_PUTUTXLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000922# define UTMPX_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000923# endif
andre2ff7b5d2000-06-03 14:57:40 +0000924
925
926/* write a utmpx entry with the system's help (pututxline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000927# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000928static int
andre61e67252000-06-04 17:07:49 +0000929utmpx_write_library(struct logininfo *li, struct utmpx *utx)
930{
andre2ff7b5d2000-06-03 14:57:40 +0000931 setutxent();
932 pututxline(utx);
933
Damien Millerdd47aa22000-06-27 11:18:27 +1000934# ifdef HAVE_ENDUTXENT
andre2ff7b5d2000-06-03 14:57:40 +0000935 endutxent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000936# endif
andre2ff7b5d2000-06-03 14:57:40 +0000937 return 1;
andre61e67252000-06-04 17:07:49 +0000938}
andre2ff7b5d2000-06-03 14:57:40 +0000939
Damien Millerdd47aa22000-06-27 11:18:27 +1000940# else /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000941
942/* write a utmp entry direct to the file */
943static int
andre61e67252000-06-04 17:07:49 +0000944utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000945{
Damien Miller996acd22003-04-09 20:59:48 +1000946 logit("utmpx_write_direct: not implemented!");
andre2ff7b5d2000-06-03 14:57:40 +0000947 return 0;
andre61e67252000-06-04 17:07:49 +0000948}
Damien Millerdd47aa22000-06-27 11:18:27 +1000949# endif /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000950
951static int
andre61e67252000-06-04 17:07:49 +0000952utmpx_perform_login(struct logininfo *li)
953{
andre2ff7b5d2000-06-03 14:57:40 +0000954 struct utmpx utx;
955
956 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000957# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000958 if (!utmpx_write_library(li, &utx)) {
Damien Miller996acd22003-04-09 20:59:48 +1000959 logit("utmpx_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000960 return 0;
961 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000962# else
andre2ff7b5d2000-06-03 14:57:40 +0000963 if (!utmpx_write_direct(li, &ut)) {
Damien Miller996acd22003-04-09 20:59:48 +1000964 logit("utmpx_perform_login: utmp_write_direct() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000965 return 0;
966 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000967# endif
andre2ff7b5d2000-06-03 14:57:40 +0000968 return 1;
andre61e67252000-06-04 17:07:49 +0000969}
andre2ff7b5d2000-06-03 14:57:40 +0000970
971
972static int
andre61e67252000-06-04 17:07:49 +0000973utmpx_perform_logout(struct logininfo *li)
974{
andre2ff7b5d2000-06-03 14:57:40 +0000975 struct utmpx utx;
976
Tim Ricee06ae4a2002-02-24 17:56:46 -0800977 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000978# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000979 line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000980# endif
981# ifdef HAVE_TYPE_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000982 utx.ut_type = DEAD_PROCESS;
Damien Millerdd47aa22000-06-27 11:18:27 +1000983# endif
andre2ff7b5d2000-06-03 14:57:40 +0000984
Damien Millerdd47aa22000-06-27 11:18:27 +1000985# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000986 utmpx_write_library(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000987# else
andre2ff7b5d2000-06-03 14:57:40 +0000988 utmpx_write_direct(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000989# endif
andre2ff7b5d2000-06-03 14:57:40 +0000990 return 1;
andre61e67252000-06-04 17:07:49 +0000991}
andre2ff7b5d2000-06-03 14:57:40 +0000992
andre2ff7b5d2000-06-03 14:57:40 +0000993int
andre61e67252000-06-04 17:07:49 +0000994utmpx_write_entry(struct logininfo *li)
995{
andre2ff7b5d2000-06-03 14:57:40 +0000996 switch(li->type) {
997 case LTYPE_LOGIN:
998 return utmpx_perform_login(li);
999 case LTYPE_LOGOUT:
1000 return utmpx_perform_logout(li);
1001 default:
Damien Miller996acd22003-04-09 20:59:48 +10001002 logit("utmpx_write_entry: invalid type field");
andre2ff7b5d2000-06-03 14:57:40 +00001003 return 0;
1004 }
andre61e67252000-06-04 17:07:49 +00001005}
Damien Millerdd47aa22000-06-27 11:18:27 +10001006#endif /* USE_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001007
1008
1009/**
andre61e67252000-06-04 17:07:49 +00001010 ** Low-level wtmp functions
andre2ff7b5d2000-06-03 14:57:40 +00001011 **/
1012
Kevin Stevesef4eea92001-02-05 12:42:17 +00001013#ifdef USE_WTMP
andre2ff7b5d2000-06-03 14:57:40 +00001014
andre2ff7b5d2000-06-03 14:57:40 +00001015/* write a wtmp entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001016/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001017static int
andre61e67252000-06-04 17:07:49 +00001018wtmp_write(struct logininfo *li, struct utmp *ut)
1019{
andre2ff7b5d2000-06-03 14:57:40 +00001020 struct stat buf;
1021 int fd, ret = 1;
1022
1023 if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001024 logit("wtmp_write: problem writing %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001025 WTMP_FILE, strerror(errno));
1026 return 0;
1027 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001028 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001029 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001030 ftruncate(fd, buf.st_size);
Damien Miller996acd22003-04-09 20:59:48 +10001031 logit("wtmp_write: problem writing %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001032 WTMP_FILE, strerror(errno));
1033 ret = 0;
1034 }
1035 (void)close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001036 return ret;
andre61e67252000-06-04 17:07:49 +00001037}
andre2ff7b5d2000-06-03 14:57:40 +00001038
andre2ff7b5d2000-06-03 14:57:40 +00001039static int
Damien Millerdd47aa22000-06-27 11:18:27 +10001040wtmp_perform_login(struct logininfo *li)
1041{
andre2ff7b5d2000-06-03 14:57:40 +00001042 struct utmp ut;
1043
1044 construct_utmp(li, &ut);
1045 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001046}
andre2ff7b5d2000-06-03 14:57:40 +00001047
1048
1049static int
andre61e67252000-06-04 17:07:49 +00001050wtmp_perform_logout(struct logininfo *li)
1051{
andre2ff7b5d2000-06-03 14:57:40 +00001052 struct utmp ut;
1053
1054 construct_utmp(li, &ut);
andre2ff7b5d2000-06-03 14:57:40 +00001055 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001056}
andre2ff7b5d2000-06-03 14:57:40 +00001057
1058
1059int
andre61e67252000-06-04 17:07:49 +00001060wtmp_write_entry(struct logininfo *li)
1061{
andre2ff7b5d2000-06-03 14:57:40 +00001062 switch(li->type) {
1063 case LTYPE_LOGIN:
1064 return wtmp_perform_login(li);
1065 case LTYPE_LOGOUT:
1066 return wtmp_perform_logout(li);
1067 default:
Damien Miller996acd22003-04-09 20:59:48 +10001068 logit("wtmp_write_entry: invalid type field");
andre2ff7b5d2000-06-03 14:57:40 +00001069 return 0;
1070 }
andre61e67252000-06-04 17:07:49 +00001071}
andre2ff7b5d2000-06-03 14:57:40 +00001072
1073
andre6bb92372000-06-19 08:20:03 +00001074/* Notes on fetching login data from wtmp/wtmpx
Kevin Stevesef4eea92001-02-05 12:42:17 +00001075 *
andre6bb92372000-06-19 08:20:03 +00001076 * Logouts are usually recorded with (amongst other things) a blank
1077 * username on a given tty line. However, some systems (HP-UX is one)
1078 * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1079 *
1080 * Since we're only looking for logins here, we know that the username
1081 * must be set correctly. On systems that leave it in, we check for
1082 * ut_type==USER_PROCESS (indicating a login.)
1083 *
1084 * Portability: Some systems may set something other than USER_PROCESS
1085 * to indicate a login process. I don't know of any as I write. Also,
1086 * it's possible that some systems may both leave the username in
1087 * place and not have ut_type.
1088 */
1089
andre6bb92372000-06-19 08:20:03 +00001090/* return true if this wtmp entry indicates a login */
1091static int
1092wtmp_islogin(struct logininfo *li, struct utmp *ut)
1093{
Kevin Stevesef4eea92001-02-05 12:42:17 +00001094 if (strncmp(li->username, ut->ut_name,
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001095 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001096# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001097 if (ut->ut_type & USER_PROCESS)
1098 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001099# else
andre6bb92372000-06-19 08:20:03 +00001100 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001101# endif
andre6bb92372000-06-19 08:20:03 +00001102 }
1103 return 0;
1104}
1105
andre2ff7b5d2000-06-03 14:57:40 +00001106int
andre61e67252000-06-04 17:07:49 +00001107wtmp_get_entry(struct logininfo *li)
1108{
andre2ff7b5d2000-06-03 14:57:40 +00001109 struct stat st;
1110 struct utmp ut;
andre6bb92372000-06-19 08:20:03 +00001111 int fd, found=0;
1112
1113 /* Clear the time entries in our logininfo */
1114 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001115
1116 if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001117 logit("wtmp_get_entry: problem opening %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001118 WTMP_FILE, strerror(errno));
1119 return 0;
1120 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001121 if (fstat(fd, &st) != 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001122 logit("wtmp_get_entry: couldn't stat %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001123 WTMP_FILE, strerror(errno));
1124 close(fd);
1125 return 0;
1126 }
andre2ff7b5d2000-06-03 14:57:40 +00001127
andre6bb92372000-06-19 08:20:03 +00001128 /* Seek to the start of the last struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001129 if (lseek(fd, -(off_t)sizeof(struct utmp), SEEK_END) == -1) {
andre6bb92372000-06-19 08:20:03 +00001130 /* Looks like we've got a fresh wtmp file */
1131 close(fd);
1132 return 0;
1133 }
1134
1135 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001136 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
Damien Miller996acd22003-04-09 20:59:48 +10001137 logit("wtmp_get_entry: read of %s failed: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001138 WTMP_FILE, strerror(errno));
1139 close (fd);
1140 return 0;
1141 }
andre6bb92372000-06-19 08:20:03 +00001142 if ( wtmp_islogin(li, &ut) ) {
1143 found = 1;
1144 /* We've already checked for a time in struct
1145 * utmp, in login_getlast(). */
Damien Millerdd47aa22000-06-27 11:18:27 +10001146# ifdef HAVE_TIME_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +00001147 li->tv_sec = ut.ut_time;
Damien Millerdd47aa22000-06-27 11:18:27 +10001148# else
andre2ff7b5d2000-06-03 14:57:40 +00001149# if HAVE_TV_IN_UTMP
1150 li->tv_sec = ut.ut_tv.tv_sec;
1151# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001152# endif
andre6bb92372000-06-19 08:20:03 +00001153 line_fullname(li->line, ut.ut_line,
1154 MIN_SIZEOF(li->line, ut.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001155# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001156 strlcpy(li->hostname, ut.ut_host,
1157 MIN_SIZEOF(li->hostname, ut.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001158# endif
andre6bb92372000-06-19 08:20:03 +00001159 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001160 }
andre6bb92372000-06-19 08:20:03 +00001161 /* Seek back 2 x struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001162 if (lseek(fd, -(off_t)(2 * sizeof(struct utmp)), SEEK_CUR) == -1) {
andre6bb92372000-06-19 08:20:03 +00001163 /* We've found the start of the file, so quit */
andre2ff7b5d2000-06-03 14:57:40 +00001164 close (fd);
1165 return 0;
1166 }
andre6bb92372000-06-19 08:20:03 +00001167 }
1168
1169 /* We found an entry. Tidy up and return */
1170 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001171 return 1;
andre61e67252000-06-04 17:07:49 +00001172}
Damien Millerdd47aa22000-06-27 11:18:27 +10001173# endif /* USE_WTMP */
andre2ff7b5d2000-06-03 14:57:40 +00001174
1175
1176/**
andre61e67252000-06-04 17:07:49 +00001177 ** Low-level wtmpx functions
andre2ff7b5d2000-06-03 14:57:40 +00001178 **/
1179
1180#ifdef USE_WTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001181/* write a wtmpx entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001182/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001183static int
andre61e67252000-06-04 17:07:49 +00001184wtmpx_write(struct logininfo *li, struct utmpx *utx)
1185{
andre2ff7b5d2000-06-03 14:57:40 +00001186 struct stat buf;
1187 int fd, ret = 1;
1188
1189 if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001190 logit("wtmpx_write: problem opening %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001191 WTMPX_FILE, strerror(errno));
1192 return 0;
1193 }
1194
Kevin Stevesef4eea92001-02-05 12:42:17 +00001195 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001196 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001197 ftruncate(fd, buf.st_size);
Damien Miller996acd22003-04-09 20:59:48 +10001198 logit("wtmpx_write: problem writing %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001199 WTMPX_FILE, strerror(errno));
1200 ret = 0;
1201 }
1202 (void)close(fd);
1203
1204 return ret;
andre61e67252000-06-04 17:07:49 +00001205}
andre2ff7b5d2000-06-03 14:57:40 +00001206
1207
1208static int
andre61e67252000-06-04 17:07:49 +00001209wtmpx_perform_login(struct logininfo *li)
1210{
andre2ff7b5d2000-06-03 14:57:40 +00001211 struct utmpx utx;
1212
1213 construct_utmpx(li, &utx);
1214 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001215}
andre2ff7b5d2000-06-03 14:57:40 +00001216
1217
1218static int
andre61e67252000-06-04 17:07:49 +00001219wtmpx_perform_logout(struct logininfo *li)
1220{
andre2ff7b5d2000-06-03 14:57:40 +00001221 struct utmpx utx;
1222
1223 construct_utmpx(li, &utx);
andre2ff7b5d2000-06-03 14:57:40 +00001224 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001225}
andre2ff7b5d2000-06-03 14:57:40 +00001226
1227
1228int
andre61e67252000-06-04 17:07:49 +00001229wtmpx_write_entry(struct logininfo *li)
1230{
andre2ff7b5d2000-06-03 14:57:40 +00001231 switch(li->type) {
1232 case LTYPE_LOGIN:
1233 return wtmpx_perform_login(li);
1234 case LTYPE_LOGOUT:
1235 return wtmpx_perform_logout(li);
1236 default:
Damien Miller996acd22003-04-09 20:59:48 +10001237 logit("wtmpx_write_entry: invalid type field");
andre2ff7b5d2000-06-03 14:57:40 +00001238 return 0;
1239 }
andre61e67252000-06-04 17:07:49 +00001240}
andre2ff7b5d2000-06-03 14:57:40 +00001241
andre6bb92372000-06-19 08:20:03 +00001242/* Please see the notes above wtmp_islogin() for information about the
1243 next two functions */
1244
1245/* Return true if this wtmpx entry indicates a login */
1246static int
1247wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1248{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001249 if ( strncmp(li->username, utx->ut_name,
1250 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001251# ifdef HAVE_TYPE_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001252 if (utx->ut_type == USER_PROCESS)
1253 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001254# else
andre6bb92372000-06-19 08:20:03 +00001255 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001256# endif
andre6bb92372000-06-19 08:20:03 +00001257 }
1258 return 0;
1259}
1260
andre2ff7b5d2000-06-03 14:57:40 +00001261
1262int
andre61e67252000-06-04 17:07:49 +00001263wtmpx_get_entry(struct logininfo *li)
1264{
andre2ff7b5d2000-06-03 14:57:40 +00001265 struct stat st;
1266 struct utmpx utx;
andre6bb92372000-06-19 08:20:03 +00001267 int fd, found=0;
1268
1269 /* Clear the time entries */
1270 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001271
1272 if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001273 logit("wtmpx_get_entry: problem opening %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001274 WTMPX_FILE, strerror(errno));
1275 return 0;
1276 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001277 if (fstat(fd, &st) != 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001278 logit("wtmpx_get_entry: couldn't stat %s: %s",
Tim Ricecdb82942002-07-14 15:33:20 -07001279 WTMPX_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001280 close(fd);
1281 return 0;
1282 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001283
andre6bb92372000-06-19 08:20:03 +00001284 /* Seek to the start of the last struct utmpx */
Kevin Steves52172652001-10-02 00:29:00 +00001285 if (lseek(fd, -(off_t)sizeof(struct utmpx), SEEK_END) == -1 ) {
andre6bb92372000-06-19 08:20:03 +00001286 /* probably a newly rotated wtmpx file */
1287 close(fd);
1288 return 0;
1289 }
andre2ff7b5d2000-06-03 14:57:40 +00001290
andre6bb92372000-06-19 08:20:03 +00001291 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001292 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
Damien Miller996acd22003-04-09 20:59:48 +10001293 logit("wtmpx_get_entry: read of %s failed: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001294 WTMPX_FILE, strerror(errno));
1295 close (fd);
1296 return 0;
1297 }
andre2ff7b5d2000-06-03 14:57:40 +00001298 /* Logouts are recorded as a blank username on a particular line.
1299 * So, we just need to find the username in struct utmpx */
andre6bb92372000-06-19 08:20:03 +00001300 if ( wtmpx_islogin(li, &utx) ) {
Tim Rice370e0ba2002-07-14 15:50:51 -07001301 found = 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001302# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001303 li->tv_sec = utx.ut_tv.tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +10001304# else
andre2ff7b5d2000-06-03 14:57:40 +00001305# ifdef HAVE_TIME_IN_UTMPX
1306 li->tv_sec = utx.ut_time;
1307# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001308# endif
Damien Miller1a132252000-06-13 21:23:17 +10001309 line_fullname(li->line, utx.ut_line, sizeof(li->line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001310# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001311 strlcpy(li->hostname, utx.ut_host,
1312 MIN_SIZEOF(li->hostname, utx.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001313# endif
andre6bb92372000-06-19 08:20:03 +00001314 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001315 }
Kevin Steves52172652001-10-02 00:29:00 +00001316 if (lseek(fd, -(off_t)(2 * sizeof(struct utmpx)), SEEK_CUR) == -1) {
andre2ff7b5d2000-06-03 14:57:40 +00001317 close (fd);
1318 return 0;
1319 }
andre6bb92372000-06-19 08:20:03 +00001320 }
1321
1322 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001323 return 1;
andre61e67252000-06-04 17:07:49 +00001324}
Damien Millerd5bf3072000-06-07 21:32:13 +10001325#endif /* USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001326
andre2ff7b5d2000-06-03 14:57:40 +00001327/**
andre61e67252000-06-04 17:07:49 +00001328 ** Low-level libutil login() functions
andre2ff7b5d2000-06-03 14:57:40 +00001329 **/
1330
1331#ifdef USE_LOGIN
andre2ff7b5d2000-06-03 14:57:40 +00001332static int
andre61e67252000-06-04 17:07:49 +00001333syslogin_perform_login(struct logininfo *li)
1334{
andre2ff7b5d2000-06-03 14:57:40 +00001335 struct utmp *ut;
1336
Damien Miller348c9b72000-08-15 10:01:22 +10001337 if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
Damien Miller996acd22003-04-09 20:59:48 +10001338 logit("syslogin_perform_login: couldn't malloc()");
andre2ff7b5d2000-06-03 14:57:40 +00001339 return 0;
1340 }
1341 construct_utmp(li, ut);
1342 login(ut);
Damien Millerf211efc2003-03-10 11:23:06 +11001343 free(ut);
andre2ff7b5d2000-06-03 14:57:40 +00001344
1345 return 1;
andre61e67252000-06-04 17:07:49 +00001346}
1347
andre2ff7b5d2000-06-03 14:57:40 +00001348static int
andre61e67252000-06-04 17:07:49 +00001349syslogin_perform_logout(struct logininfo *li)
1350{
Damien Millerdd47aa22000-06-27 11:18:27 +10001351# ifdef HAVE_LOGOUT
andre2ff7b5d2000-06-03 14:57:40 +00001352 char line[8];
Kevin Stevesef4eea92001-02-05 12:42:17 +00001353
andre2ff7b5d2000-06-03 14:57:40 +00001354 (void)line_stripname(line, li->line, sizeof(line));
1355
1356 if (!logout(line)) {
Damien Miller996acd22003-04-09 20:59:48 +10001357 logit("syslogin_perform_logout: logout() returned an error");
Damien Millerdd47aa22000-06-27 11:18:27 +10001358# ifdef HAVE_LOGWTMP
andre2ff7b5d2000-06-03 14:57:40 +00001359 } else {
1360 logwtmp(line, "", "");
Damien Millerdd47aa22000-06-27 11:18:27 +10001361# endif
Damien Miller9b6d4ab2000-07-02 08:43:18 +10001362 }
andre6bb92372000-06-19 08:20:03 +00001363 /* FIXME: (ATL - if the need arises) What to do if we have
1364 * login, but no logout? what if logout but no logwtmp? All
1365 * routines are in libutil so they should all be there,
1366 * but... */
Damien Millerdd47aa22000-06-27 11:18:27 +10001367# endif
andre2ff7b5d2000-06-03 14:57:40 +00001368 return 1;
andre61e67252000-06-04 17:07:49 +00001369}
andre2ff7b5d2000-06-03 14:57:40 +00001370
andre2ff7b5d2000-06-03 14:57:40 +00001371int
andre61e67252000-06-04 17:07:49 +00001372syslogin_write_entry(struct logininfo *li)
1373{
andre2ff7b5d2000-06-03 14:57:40 +00001374 switch (li->type) {
1375 case LTYPE_LOGIN:
1376 return syslogin_perform_login(li);
1377 case LTYPE_LOGOUT:
1378 return syslogin_perform_logout(li);
1379 default:
Damien Miller996acd22003-04-09 20:59:48 +10001380 logit("syslogin_write_entry: Invalid type field");
andre2ff7b5d2000-06-03 14:57:40 +00001381 return 0;
1382 }
andre61e67252000-06-04 17:07:49 +00001383}
Damien Millerd5bf3072000-06-07 21:32:13 +10001384#endif /* USE_LOGIN */
andre2ff7b5d2000-06-03 14:57:40 +00001385
1386/* end of file log-syslogin.c */
1387
andre2ff7b5d2000-06-03 14:57:40 +00001388/**
andre61e67252000-06-04 17:07:49 +00001389 ** Low-level lastlog functions
andre2ff7b5d2000-06-03 14:57:40 +00001390 **/
1391
1392#ifdef USE_LASTLOG
Damien Millerdd47aa22000-06-27 11:18:27 +10001393#define LL_FILE 1
1394#define LL_DIR 2
1395#define LL_OTHER 3
andre2ff7b5d2000-06-03 14:57:40 +00001396
andre2ff7b5d2000-06-03 14:57:40 +00001397static void
andre61e67252000-06-04 17:07:49 +00001398lastlog_construct(struct logininfo *li, struct lastlog *last)
1399{
andre2ff7b5d2000-06-03 14:57:40 +00001400 /* clear the structure */
Damien Miller348c9b72000-08-15 10:01:22 +10001401 memset(last, '\0', sizeof(*last));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001402
Damien Millerdd47aa22000-06-27 11:18:27 +10001403 (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
andre6bb92372000-06-19 08:20:03 +00001404 strlcpy(last->ll_host, li->hostname,
1405 MIN_SIZEOF(last->ll_host, li->hostname));
andre2ff7b5d2000-06-03 14:57:40 +00001406 last->ll_time = li->tv_sec;
andre61e67252000-06-04 17:07:49 +00001407}
andre2ff7b5d2000-06-03 14:57:40 +00001408
andre2ff7b5d2000-06-03 14:57:40 +00001409static int
andre61e67252000-06-04 17:07:49 +00001410lastlog_filetype(char *filename)
1411{
andre2ff7b5d2000-06-03 14:57:40 +00001412 struct stat st;
1413
Damien Millerdd47aa22000-06-27 11:18:27 +10001414 if (stat(LASTLOG_FILE, &st) != 0) {
Damien Miller996acd22003-04-09 20:59:48 +10001415 logit("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
Damien Millerdd47aa22000-06-27 11:18:27 +10001416 strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001417 return 0;
1418 }
andre2ff7b5d2000-06-03 14:57:40 +00001419 if (S_ISDIR(st.st_mode))
1420 return LL_DIR;
1421 else if (S_ISREG(st.st_mode))
1422 return LL_FILE;
1423 else
1424 return LL_OTHER;
andre61e67252000-06-04 17:07:49 +00001425}
andre2ff7b5d2000-06-03 14:57:40 +00001426
1427
1428/* open the file (using filemode) and seek to the login entry */
1429static int
andre61e67252000-06-04 17:07:49 +00001430lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1431{
andre2ff7b5d2000-06-03 14:57:40 +00001432 off_t offset;
1433 int type;
1434 char lastlog_file[1024];
1435
1436 type = lastlog_filetype(LASTLOG_FILE);
1437 switch (type) {
Damien Millerf8af08d2000-06-27 09:40:06 +10001438 case LL_FILE:
1439 strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1440 break;
1441 case LL_DIR:
1442 snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1443 LASTLOG_FILE, li->username);
1444 break;
1445 default:
Damien Miller996acd22003-04-09 20:59:48 +10001446 logit("lastlog_openseek: %.100s is not a file or directory!",
Damien Millerf8af08d2000-06-27 09:40:06 +10001447 LASTLOG_FILE);
1448 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001449 }
andre2ff7b5d2000-06-03 14:57:40 +00001450
Damien Miller405dc602003-04-09 21:12:52 +10001451 *fd = open(lastlog_file, filemode, 0600);
andre2ff7b5d2000-06-03 14:57:40 +00001452 if ( *fd < 0) {
Damien Miller53c5d462000-06-28 00:50:50 +10001453 debug("lastlog_openseek: Couldn't open %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001454 lastlog_file, strerror(errno));
1455 return 0;
1456 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001457
Damien Millere477ef62000-08-15 10:21:17 +10001458 if (type == LL_FILE) {
1459 /* find this uid's offset in the lastlog file */
Kevin Steves52172652001-10-02 00:29:00 +00001460 offset = (off_t) ((long)li->uid * sizeof(struct lastlog));
andre2ff7b5d2000-06-03 14:57:40 +00001461
Damien Millere477ef62000-08-15 10:21:17 +10001462 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
Damien Miller996acd22003-04-09 20:59:48 +10001463 logit("lastlog_openseek: %s->lseek(): %s",
Kevin Stevesef4eea92001-02-05 12:42:17 +00001464 lastlog_file, strerror(errno));
Damien Millere477ef62000-08-15 10:21:17 +10001465 return 0;
1466 }
andre2ff7b5d2000-06-03 14:57:40 +00001467 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001468
andre2ff7b5d2000-06-03 14:57:40 +00001469 return 1;
andre61e67252000-06-04 17:07:49 +00001470}
andre2ff7b5d2000-06-03 14:57:40 +00001471
1472static int
andre61e67252000-06-04 17:07:49 +00001473lastlog_perform_login(struct logininfo *li)
1474{
andre2ff7b5d2000-06-03 14:57:40 +00001475 struct lastlog last;
1476 int fd;
1477
1478 /* create our struct lastlog */
1479 lastlog_construct(li, &last);
1480
Damien Miller405dc602003-04-09 21:12:52 +10001481 if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
Damien Millerc1132e72000-08-18 14:08:38 +10001482 return(0);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001483
andre2ff7b5d2000-06-03 14:57:40 +00001484 /* write the entry */
Damien Millerc1132e72000-08-18 14:08:38 +10001485 if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1486 close(fd);
Damien Miller996acd22003-04-09 20:59:48 +10001487 logit("lastlog_write_filemode: Error writing to %s: %s",
Damien Millerc1132e72000-08-18 14:08:38 +10001488 LASTLOG_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001489 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001490 }
Damien Millerc1132e72000-08-18 14:08:38 +10001491
1492 close(fd);
1493 return 1;
andre61e67252000-06-04 17:07:49 +00001494}
andre2ff7b5d2000-06-03 14:57:40 +00001495
andre2ff7b5d2000-06-03 14:57:40 +00001496int
andre61e67252000-06-04 17:07:49 +00001497lastlog_write_entry(struct logininfo *li)
1498{
andre2ff7b5d2000-06-03 14:57:40 +00001499 switch(li->type) {
1500 case LTYPE_LOGIN:
1501 return lastlog_perform_login(li);
1502 default:
Damien Miller996acd22003-04-09 20:59:48 +10001503 logit("lastlog_write_entry: Invalid type field");
andre2ff7b5d2000-06-03 14:57:40 +00001504 return 0;
1505 }
andre61e67252000-06-04 17:07:49 +00001506}
andre2ff7b5d2000-06-03 14:57:40 +00001507
andre2ff7b5d2000-06-03 14:57:40 +00001508static void
andre61e67252000-06-04 17:07:49 +00001509lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1510{
andre2ff7b5d2000-06-03 14:57:40 +00001511 line_fullname(li->line, last->ll_line, sizeof(li->line));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001512 strlcpy(li->hostname, last->ll_host,
andre6bb92372000-06-19 08:20:03 +00001513 MIN_SIZEOF(li->hostname, last->ll_host));
andre2ff7b5d2000-06-03 14:57:40 +00001514 li->tv_sec = last->ll_time;
andre61e67252000-06-04 17:07:49 +00001515}
andre2ff7b5d2000-06-03 14:57:40 +00001516
andre2ff7b5d2000-06-03 14:57:40 +00001517int
andre61e67252000-06-04 17:07:49 +00001518lastlog_get_entry(struct logininfo *li)
1519{
andre2ff7b5d2000-06-03 14:57:40 +00001520 struct lastlog last;
Damien Miller7df881d2003-01-07 16:46:58 +11001521 int fd, ret;
andre2ff7b5d2000-06-03 14:57:40 +00001522
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001523 if (!lastlog_openseek(li, &fd, O_RDONLY))
Damien Miller7df881d2003-01-07 16:46:58 +11001524 return (0);
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001525
Damien Miller7df881d2003-01-07 16:46:58 +11001526 ret = atomicio(read, fd, &last, sizeof(last));
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001527 close(fd);
1528
Damien Miller7df881d2003-01-07 16:46:58 +11001529 switch (ret) {
1530 case 0:
1531 memset(&last, '\0', sizeof(last));
1532 /* FALLTHRU */
1533 case sizeof(last):
1534 lastlog_populate_entry(li, &last);
1535 return (1);
1536 case -1:
1537 error("%s: Error reading from %s: %s", __func__,
1538 LASTLOG_FILE, strerror(errno));
1539 return (0);
1540 default:
1541 error("%s: Error reading from %s: Expecting %d, got %d",
1542 __func__, LASTLOG_FILE, sizeof(last), ret);
1543 return (0);
1544 }
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001545
Damien Miller7df881d2003-01-07 16:46:58 +11001546 /* NOTREACHED */
1547 return (0);
andre61e67252000-06-04 17:07:49 +00001548}
Damien Millerd5bf3072000-06-07 21:32:13 +10001549#endif /* USE_LASTLOG */