blob: 02c3106a3b8f8f5cd609f9c2dc3e69a11be1cba7 [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
Tim Rice81ed5182002-09-25 17:38:46 -0700166RCSID("$Id: loginrec.c,v 1.44 2002/09/26 00:38:49 tim 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 Miller348c9b72000-08-15 10:01:22 +1000612 memset(ut, '\0', sizeof(*ut));
andre6bb92372000-06-19 08:20:03 +0000613
614 /* First fill out fields used for both logins and logouts */
615
Damien Millerdd47aa22000-06-27 11:18:27 +1000616# ifdef HAVE_ID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000617 line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000618# endif
andre2ff7b5d2000-06-03 14:57:40 +0000619
Damien Millerdd47aa22000-06-27 11:18:27 +1000620# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000621 /* This is done here to keep utmp constants out of struct logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000622 switch (li->type) {
623 case LTYPE_LOGIN:
624 ut->ut_type = USER_PROCESS;
Tim Rice81ed5182002-09-25 17:38:46 -0700625#ifdef _UNICOS
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000626 cray_set_tmpdir(ut);
627#endif
andre2ff7b5d2000-06-03 14:57:40 +0000628 break;
629 case LTYPE_LOGOUT:
630 ut->ut_type = DEAD_PROCESS;
Tim Rice81ed5182002-09-25 17:38:46 -0700631#ifdef _UNICOS
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000632 cray_retain_utmp(ut, li->pid);
633#endif
andre2ff7b5d2000-06-03 14:57:40 +0000634 break;
635 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000636# endif
andre6bb92372000-06-19 08:20:03 +0000637 set_utmp_time(li, ut);
andre2ff7b5d2000-06-03 14:57:40 +0000638
andre6bb92372000-06-19 08:20:03 +0000639 line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000640
641# ifdef HAVE_PID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000642 ut->ut_pid = li->pid;
Damien Millerdd47aa22000-06-27 11:18:27 +1000643# endif
andre6bb92372000-06-19 08:20:03 +0000644
645 /* If we're logging out, leave all other fields blank */
646 if (li->type == LTYPE_LOGOUT)
647 return;
648
Damien Millerdd47aa22000-06-27 11:18:27 +1000649 /*
650 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000651 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000652 */
andre6bb92372000-06-19 08:20:03 +0000653
654 /* Use strncpy because we don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000655 strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000656# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000657 strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000658# endif
659# ifdef HAVE_ADDR_IN_UTMP
andre61e67252000-06-04 17:07:49 +0000660 /* this is just a 32-bit IP address */
661 if (li->hostaddr.sa.sa_family == AF_INET)
662 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000663# endif
andre61e67252000-06-04 17:07:49 +0000664}
Damien Millerdd47aa22000-06-27 11:18:27 +1000665#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
andre61e67252000-06-04 17:07:49 +0000666
andre2ff7b5d2000-06-03 14:57:40 +0000667/**
668 ** utmpx utility functions
andre61e67252000-06-04 17:07:49 +0000669 **
670 ** These functions manipulate struct utmpx, accounting for system
671 ** variations.
andre2ff7b5d2000-06-03 14:57:40 +0000672 **/
673
674#if defined(USE_UTMPX) || defined (USE_WTMPX)
andre2ff7b5d2000-06-03 14:57:40 +0000675/* build the utmpx structure */
676void
andre61e67252000-06-04 17:07:49 +0000677set_utmpx_time(struct logininfo *li, struct utmpx *utx)
678{
Damien Millerdd47aa22000-06-27 11:18:27 +1000679# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000680 utx->ut_tv.tv_sec = li->tv_sec;
681 utx->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000682# else /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000683# ifdef HAVE_TIME_IN_UTMPX
684 utx->ut_time = li->tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000685# endif /* HAVE_TIME_IN_UTMPX */
686# endif /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000687}
688
andre61e67252000-06-04 17:07:49 +0000689void
690construct_utmpx(struct logininfo *li, struct utmpx *utx)
691{
Damien Miller348c9b72000-08-15 10:01:22 +1000692 memset(utx, '\0', sizeof(*utx));
Damien Miller8e81ed32000-07-01 13:17:42 +1000693# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000694 line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
Damien Miller8e81ed32000-07-01 13:17:42 +1000695# endif
andre2ff7b5d2000-06-03 14:57:40 +0000696
697 /* this is done here to keep utmp constants out of loginrec.h */
698 switch (li->type) {
699 case LTYPE_LOGIN:
700 utx->ut_type = USER_PROCESS;
701 break;
702 case LTYPE_LOGOUT:
703 utx->ut_type = DEAD_PROCESS;
704 break;
705 }
andre2ff7b5d2000-06-03 14:57:40 +0000706 line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
andre2ff7b5d2000-06-03 14:57:40 +0000707 set_utmpx_time(li, utx);
andre6bb92372000-06-19 08:20:03 +0000708 utx->ut_pid = li->pid;
Tim Ricee06ae4a2002-02-24 17:56:46 -0800709 /* strncpy(): Don't necessarily want null termination */
710 strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
andre6bb92372000-06-19 08:20:03 +0000711
712 if (li->type == LTYPE_LOGOUT)
713 return;
714
Damien Millerdd47aa22000-06-27 11:18:27 +1000715 /*
716 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000717 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000718 */
andre6bb92372000-06-19 08:20:03 +0000719
Damien Millerdd47aa22000-06-27 11:18:27 +1000720# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000721 strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000722# endif
723# ifdef HAVE_ADDR_IN_UTMPX
Damien Millerd6f204d2000-09-23 13:57:27 +1100724 /* this is just a 32-bit IP address */
725 if (li->hostaddr.sa.sa_family == AF_INET)
726 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Damien Millerdd47aa22000-06-27 11:18:27 +1000727# endif
728# ifdef HAVE_SYSLEN_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000729 /* ut_syslen is the length of the utx_host string */
730 utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +1000731# endif
andre61e67252000-06-04 17:07:49 +0000732}
Damien Millerdd47aa22000-06-27 11:18:27 +1000733#endif /* USE_UTMPX || USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000734
735/**
andre61e67252000-06-04 17:07:49 +0000736 ** Low-level utmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000737 **/
738
739/* FIXME: (ATL) utmp_write_direct needs testing */
andre2ff7b5d2000-06-03 14:57:40 +0000740#ifdef USE_UTMP
741
andre2ff7b5d2000-06-03 14:57:40 +0000742/* if we can, use pututline() etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000743# if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
744 defined(HAVE_PUTUTLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000745# define UTMP_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000746# endif
andre2ff7b5d2000-06-03 14:57:40 +0000747
748
749/* write a utmp entry with the system's help (pututline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000750# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000751static int
andre61e67252000-06-04 17:07:49 +0000752utmp_write_library(struct logininfo *li, struct utmp *ut)
753{
andre2ff7b5d2000-06-03 14:57:40 +0000754 setutent();
755 pututline(ut);
756
Damien Millerdd47aa22000-06-27 11:18:27 +1000757# ifdef HAVE_ENDUTENT
andre2ff7b5d2000-06-03 14:57:40 +0000758 endutent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000759# endif
andre2ff7b5d2000-06-03 14:57:40 +0000760 return 1;
andre61e67252000-06-04 17:07:49 +0000761}
Damien Millerdd47aa22000-06-27 11:18:27 +1000762# else /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000763
764/* write a utmp entry direct to the file */
andre61e67252000-06-04 17:07:49 +0000765/* This is a slightly modification of code in OpenBSD's login.c */
andre2ff7b5d2000-06-03 14:57:40 +0000766static int
andre61e67252000-06-04 17:07:49 +0000767utmp_write_direct(struct logininfo *li, struct utmp *ut)
768{
andre2ff7b5d2000-06-03 14:57:40 +0000769 struct utmp old_ut;
770 register int fd;
771 int tty;
772
andre6bb92372000-06-19 08:20:03 +0000773 /* FIXME: (ATL) ttyslot() needs local implementation */
Damien Miller348c9b72000-08-15 10:01:22 +1000774
Damien Millere5192fa2000-08-29 14:30:37 +1100775#if defined(HAVE_GETTTYENT)
Damien Miller348c9b72000-08-15 10:01:22 +1000776 register struct ttyent *ty;
777
778 tty=0;
779
780 setttyent();
781 while ((struct ttyent *)0 != (ty = getttyent())) {
782 tty++;
783 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
784 break;
785 }
786 endttyent();
787
788 if((struct ttyent *)0 == ty) {
789 log("utmp_write_entry: tty not found");
790 return(1);
791 }
792#else /* FIXME */
793
andre2ff7b5d2000-06-03 14:57:40 +0000794 tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
795
Damien Millere5192fa2000-08-29 14:30:37 +1100796#endif /* HAVE_GETTTYENT */
Damien Miller348c9b72000-08-15 10:01:22 +1000797
andre2ff7b5d2000-06-03 14:57:40 +0000798 if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
799 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
800 /*
801 * Prevent luser from zero'ing out ut_host.
802 * If the new ut_line is empty but the old one is not
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000803 * and ut_line and ut_name match, preserve the old ut_line.
andre2ff7b5d2000-06-03 14:57:40 +0000804 */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000805 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
806 (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
807 (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000808 (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
andre2ff7b5d2000-06-03 14:57:40 +0000809 (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
Damien Miller53c5d462000-06-28 00:50:50 +1000810 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000811
andre2ff7b5d2000-06-03 14:57:40 +0000812 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
Damien Miller36ccb5c2000-08-09 16:34:27 +1000813 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
andre2ff7b5d2000-06-03 14:57:40 +0000814 log("utmp_write_direct: error writing %s: %s",
andre6bb92372000-06-19 08:20:03 +0000815 UTMP_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000816
andre2ff7b5d2000-06-03 14:57:40 +0000817 (void)close(fd);
818 return 1;
Damien Miller53c5d462000-06-28 00:50:50 +1000819 } else {
andre2ff7b5d2000-06-03 14:57:40 +0000820 return 0;
Damien Miller53c5d462000-06-28 00:50:50 +1000821 }
andre61e67252000-06-04 17:07:49 +0000822}
Damien Millerdd47aa22000-06-27 11:18:27 +1000823# endif /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000824
825static int
andre61e67252000-06-04 17:07:49 +0000826utmp_perform_login(struct logininfo *li)
827{
andre2ff7b5d2000-06-03 14:57:40 +0000828 struct utmp ut;
829
830 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000831# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000832 if (!utmp_write_library(li, &ut)) {
andre6bb92372000-06-19 08:20:03 +0000833 log("utmp_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000834 return 0;
835 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000836# else
andre2ff7b5d2000-06-03 14:57:40 +0000837 if (!utmp_write_direct(li, &ut)) {
838 log("utmp_perform_login: utmp_write_direct() failed");
839 return 0;
840 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000841# endif
andre2ff7b5d2000-06-03 14:57:40 +0000842 return 1;
andre61e67252000-06-04 17:07:49 +0000843}
andre2ff7b5d2000-06-03 14:57:40 +0000844
845
846static int
andre61e67252000-06-04 17:07:49 +0000847utmp_perform_logout(struct logininfo *li)
848{
andre2ff7b5d2000-06-03 14:57:40 +0000849 struct utmp ut;
850
andre6bb92372000-06-19 08:20:03 +0000851 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000852# ifdef UTMP_USE_LIBRARY
andre6bb92372000-06-19 08:20:03 +0000853 if (!utmp_write_library(li, &ut)) {
854 log("utmp_perform_logout: utmp_write_library() failed");
855 return 0;
856 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000857# else
andre6bb92372000-06-19 08:20:03 +0000858 if (!utmp_write_direct(li, &ut)) {
859 log("utmp_perform_logout: utmp_write_direct() failed");
860 return 0;
861 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000862# endif
andre2ff7b5d2000-06-03 14:57:40 +0000863 return 1;
andre61e67252000-06-04 17:07:49 +0000864}
andre2ff7b5d2000-06-03 14:57:40 +0000865
866
867int
andre61e67252000-06-04 17:07:49 +0000868utmp_write_entry(struct logininfo *li)
869{
andre2ff7b5d2000-06-03 14:57:40 +0000870 switch(li->type) {
871 case LTYPE_LOGIN:
872 return utmp_perform_login(li);
873
874 case LTYPE_LOGOUT:
875 return utmp_perform_logout(li);
876
877 default:
878 log("utmp_write_entry: invalid type field");
879 return 0;
880 }
andre61e67252000-06-04 17:07:49 +0000881}
Damien Millerdd47aa22000-06-27 11:18:27 +1000882#endif /* USE_UTMP */
andre2ff7b5d2000-06-03 14:57:40 +0000883
884
885/**
andre61e67252000-06-04 17:07:49 +0000886 ** Low-level utmpx functions
andre2ff7b5d2000-06-03 14:57:40 +0000887 **/
888
889/* not much point if we don't want utmpx entries */
890#ifdef USE_UTMPX
891
andre2ff7b5d2000-06-03 14:57:40 +0000892/* if we have the wherewithall, use pututxline etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000893# if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
894 defined(HAVE_PUTUTXLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000895# define UTMPX_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000896# endif
andre2ff7b5d2000-06-03 14:57:40 +0000897
898
899/* write a utmpx entry with the system's help (pututxline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000900# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000901static int
andre61e67252000-06-04 17:07:49 +0000902utmpx_write_library(struct logininfo *li, struct utmpx *utx)
903{
andre2ff7b5d2000-06-03 14:57:40 +0000904 setutxent();
905 pututxline(utx);
906
Damien Millerdd47aa22000-06-27 11:18:27 +1000907# ifdef HAVE_ENDUTXENT
andre2ff7b5d2000-06-03 14:57:40 +0000908 endutxent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000909# endif
andre2ff7b5d2000-06-03 14:57:40 +0000910 return 1;
andre61e67252000-06-04 17:07:49 +0000911}
andre2ff7b5d2000-06-03 14:57:40 +0000912
Damien Millerdd47aa22000-06-27 11:18:27 +1000913# else /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000914
915/* write a utmp entry direct to the file */
916static int
andre61e67252000-06-04 17:07:49 +0000917utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000918{
andre2ff7b5d2000-06-03 14:57:40 +0000919 log("utmpx_write_direct: not implemented!");
920 return 0;
andre61e67252000-06-04 17:07:49 +0000921}
Damien Millerdd47aa22000-06-27 11:18:27 +1000922# endif /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000923
924static int
andre61e67252000-06-04 17:07:49 +0000925utmpx_perform_login(struct logininfo *li)
926{
andre2ff7b5d2000-06-03 14:57:40 +0000927 struct utmpx utx;
928
929 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000930# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000931 if (!utmpx_write_library(li, &utx)) {
932 log("utmpx_perform_login: utmp_write_library() failed");
933 return 0;
934 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000935# else
andre2ff7b5d2000-06-03 14:57:40 +0000936 if (!utmpx_write_direct(li, &ut)) {
937 log("utmpx_perform_login: utmp_write_direct() failed");
938 return 0;
939 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000940# endif
andre2ff7b5d2000-06-03 14:57:40 +0000941 return 1;
andre61e67252000-06-04 17:07:49 +0000942}
andre2ff7b5d2000-06-03 14:57:40 +0000943
944
945static int
andre61e67252000-06-04 17:07:49 +0000946utmpx_perform_logout(struct logininfo *li)
947{
andre2ff7b5d2000-06-03 14:57:40 +0000948 struct utmpx utx;
949
Tim Ricee06ae4a2002-02-24 17:56:46 -0800950 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000951# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000952 line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000953# endif
954# ifdef HAVE_TYPE_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000955 utx.ut_type = DEAD_PROCESS;
Damien Millerdd47aa22000-06-27 11:18:27 +1000956# endif
andre2ff7b5d2000-06-03 14:57:40 +0000957
Damien Millerdd47aa22000-06-27 11:18:27 +1000958# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000959 utmpx_write_library(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000960# else
andre2ff7b5d2000-06-03 14:57:40 +0000961 utmpx_write_direct(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000962# endif
andre2ff7b5d2000-06-03 14:57:40 +0000963 return 1;
andre61e67252000-06-04 17:07:49 +0000964}
andre2ff7b5d2000-06-03 14:57:40 +0000965
andre2ff7b5d2000-06-03 14:57:40 +0000966int
andre61e67252000-06-04 17:07:49 +0000967utmpx_write_entry(struct logininfo *li)
968{
andre2ff7b5d2000-06-03 14:57:40 +0000969 switch(li->type) {
970 case LTYPE_LOGIN:
971 return utmpx_perform_login(li);
972 case LTYPE_LOGOUT:
973 return utmpx_perform_logout(li);
974 default:
975 log("utmpx_write_entry: invalid type field");
976 return 0;
977 }
andre61e67252000-06-04 17:07:49 +0000978}
Damien Millerdd47aa22000-06-27 11:18:27 +1000979#endif /* USE_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000980
981
982/**
andre61e67252000-06-04 17:07:49 +0000983 ** Low-level wtmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000984 **/
985
Kevin Stevesef4eea92001-02-05 12:42:17 +0000986#ifdef USE_WTMP
andre2ff7b5d2000-06-03 14:57:40 +0000987
andre2ff7b5d2000-06-03 14:57:40 +0000988/* write a wtmp entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +0000989/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +0000990static int
andre61e67252000-06-04 17:07:49 +0000991wtmp_write(struct logininfo *li, struct utmp *ut)
992{
andre2ff7b5d2000-06-03 14:57:40 +0000993 struct stat buf;
994 int fd, ret = 1;
995
996 if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
997 log("wtmp_write: problem writing %s: %s",
998 WTMP_FILE, strerror(errno));
999 return 0;
1000 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001001 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001002 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001003 ftruncate(fd, buf.st_size);
1004 log("wtmp_write: problem writing %s: %s",
1005 WTMP_FILE, strerror(errno));
1006 ret = 0;
1007 }
1008 (void)close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001009 return ret;
andre61e67252000-06-04 17:07:49 +00001010}
andre2ff7b5d2000-06-03 14:57:40 +00001011
andre2ff7b5d2000-06-03 14:57:40 +00001012static int
Damien Millerdd47aa22000-06-27 11:18:27 +10001013wtmp_perform_login(struct logininfo *li)
1014{
andre2ff7b5d2000-06-03 14:57:40 +00001015 struct utmp ut;
1016
1017 construct_utmp(li, &ut);
1018 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001019}
andre2ff7b5d2000-06-03 14:57:40 +00001020
1021
1022static int
andre61e67252000-06-04 17:07:49 +00001023wtmp_perform_logout(struct logininfo *li)
1024{
andre2ff7b5d2000-06-03 14:57:40 +00001025 struct utmp ut;
1026
1027 construct_utmp(li, &ut);
andre2ff7b5d2000-06-03 14:57:40 +00001028 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001029}
andre2ff7b5d2000-06-03 14:57:40 +00001030
1031
1032int
andre61e67252000-06-04 17:07:49 +00001033wtmp_write_entry(struct logininfo *li)
1034{
andre2ff7b5d2000-06-03 14:57:40 +00001035 switch(li->type) {
1036 case LTYPE_LOGIN:
1037 return wtmp_perform_login(li);
1038 case LTYPE_LOGOUT:
1039 return wtmp_perform_logout(li);
1040 default:
1041 log("wtmp_write_entry: invalid type field");
1042 return 0;
1043 }
andre61e67252000-06-04 17:07:49 +00001044}
andre2ff7b5d2000-06-03 14:57:40 +00001045
1046
andre6bb92372000-06-19 08:20:03 +00001047/* Notes on fetching login data from wtmp/wtmpx
Kevin Stevesef4eea92001-02-05 12:42:17 +00001048 *
andre6bb92372000-06-19 08:20:03 +00001049 * Logouts are usually recorded with (amongst other things) a blank
1050 * username on a given tty line. However, some systems (HP-UX is one)
1051 * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1052 *
1053 * Since we're only looking for logins here, we know that the username
1054 * must be set correctly. On systems that leave it in, we check for
1055 * ut_type==USER_PROCESS (indicating a login.)
1056 *
1057 * Portability: Some systems may set something other than USER_PROCESS
1058 * to indicate a login process. I don't know of any as I write. Also,
1059 * it's possible that some systems may both leave the username in
1060 * place and not have ut_type.
1061 */
1062
andre6bb92372000-06-19 08:20:03 +00001063/* return true if this wtmp entry indicates a login */
1064static int
1065wtmp_islogin(struct logininfo *li, struct utmp *ut)
1066{
Kevin Stevesef4eea92001-02-05 12:42:17 +00001067 if (strncmp(li->username, ut->ut_name,
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001068 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001069# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001070 if (ut->ut_type & USER_PROCESS)
1071 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001072# else
andre6bb92372000-06-19 08:20:03 +00001073 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001074# endif
andre6bb92372000-06-19 08:20:03 +00001075 }
1076 return 0;
1077}
1078
andre2ff7b5d2000-06-03 14:57:40 +00001079int
andre61e67252000-06-04 17:07:49 +00001080wtmp_get_entry(struct logininfo *li)
1081{
andre2ff7b5d2000-06-03 14:57:40 +00001082 struct stat st;
1083 struct utmp ut;
andre6bb92372000-06-19 08:20:03 +00001084 int fd, found=0;
1085
1086 /* Clear the time entries in our logininfo */
1087 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001088
1089 if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1090 log("wtmp_get_entry: problem opening %s: %s",
1091 WTMP_FILE, strerror(errno));
1092 return 0;
1093 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001094 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001095 log("wtmp_get_entry: couldn't stat %s: %s",
1096 WTMP_FILE, strerror(errno));
1097 close(fd);
1098 return 0;
1099 }
andre2ff7b5d2000-06-03 14:57:40 +00001100
andre6bb92372000-06-19 08:20:03 +00001101 /* Seek to the start of the last struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001102 if (lseek(fd, -(off_t)sizeof(struct utmp), SEEK_END) == -1) {
andre6bb92372000-06-19 08:20:03 +00001103 /* Looks like we've got a fresh wtmp file */
1104 close(fd);
1105 return 0;
1106 }
1107
1108 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001109 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001110 log("wtmp_get_entry: read of %s failed: %s",
1111 WTMP_FILE, strerror(errno));
1112 close (fd);
1113 return 0;
1114 }
andre6bb92372000-06-19 08:20:03 +00001115 if ( wtmp_islogin(li, &ut) ) {
1116 found = 1;
1117 /* We've already checked for a time in struct
1118 * utmp, in login_getlast(). */
Damien Millerdd47aa22000-06-27 11:18:27 +10001119# ifdef HAVE_TIME_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +00001120 li->tv_sec = ut.ut_time;
Damien Millerdd47aa22000-06-27 11:18:27 +10001121# else
andre2ff7b5d2000-06-03 14:57:40 +00001122# if HAVE_TV_IN_UTMP
1123 li->tv_sec = ut.ut_tv.tv_sec;
1124# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001125# endif
andre6bb92372000-06-19 08:20:03 +00001126 line_fullname(li->line, ut.ut_line,
1127 MIN_SIZEOF(li->line, ut.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001128# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001129 strlcpy(li->hostname, ut.ut_host,
1130 MIN_SIZEOF(li->hostname, ut.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001131# endif
andre6bb92372000-06-19 08:20:03 +00001132 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001133 }
andre6bb92372000-06-19 08:20:03 +00001134 /* Seek back 2 x struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001135 if (lseek(fd, -(off_t)(2 * sizeof(struct utmp)), SEEK_CUR) == -1) {
andre6bb92372000-06-19 08:20:03 +00001136 /* We've found the start of the file, so quit */
andre2ff7b5d2000-06-03 14:57:40 +00001137 close (fd);
1138 return 0;
1139 }
andre6bb92372000-06-19 08:20:03 +00001140 }
1141
1142 /* We found an entry. Tidy up and return */
1143 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001144 return 1;
andre61e67252000-06-04 17:07:49 +00001145}
Damien Millerdd47aa22000-06-27 11:18:27 +10001146# endif /* USE_WTMP */
andre2ff7b5d2000-06-03 14:57:40 +00001147
1148
1149/**
andre61e67252000-06-04 17:07:49 +00001150 ** Low-level wtmpx functions
andre2ff7b5d2000-06-03 14:57:40 +00001151 **/
1152
1153#ifdef USE_WTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001154/* write a wtmpx entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001155/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001156static int
andre61e67252000-06-04 17:07:49 +00001157wtmpx_write(struct logininfo *li, struct utmpx *utx)
1158{
andre2ff7b5d2000-06-03 14:57:40 +00001159 struct stat buf;
1160 int fd, ret = 1;
1161
1162 if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1163 log("wtmpx_write: problem opening %s: %s",
1164 WTMPX_FILE, strerror(errno));
1165 return 0;
1166 }
1167
Kevin Stevesef4eea92001-02-05 12:42:17 +00001168 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001169 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001170 ftruncate(fd, buf.st_size);
1171 log("wtmpx_write: problem writing %s: %s",
1172 WTMPX_FILE, strerror(errno));
1173 ret = 0;
1174 }
1175 (void)close(fd);
1176
1177 return ret;
andre61e67252000-06-04 17:07:49 +00001178}
andre2ff7b5d2000-06-03 14:57:40 +00001179
1180
1181static int
andre61e67252000-06-04 17:07:49 +00001182wtmpx_perform_login(struct logininfo *li)
1183{
andre2ff7b5d2000-06-03 14:57:40 +00001184 struct utmpx utx;
1185
1186 construct_utmpx(li, &utx);
1187 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001188}
andre2ff7b5d2000-06-03 14:57:40 +00001189
1190
1191static int
andre61e67252000-06-04 17:07:49 +00001192wtmpx_perform_logout(struct logininfo *li)
1193{
andre2ff7b5d2000-06-03 14:57:40 +00001194 struct utmpx utx;
1195
1196 construct_utmpx(li, &utx);
andre2ff7b5d2000-06-03 14:57:40 +00001197 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001198}
andre2ff7b5d2000-06-03 14:57:40 +00001199
1200
1201int
andre61e67252000-06-04 17:07:49 +00001202wtmpx_write_entry(struct logininfo *li)
1203{
andre2ff7b5d2000-06-03 14:57:40 +00001204 switch(li->type) {
1205 case LTYPE_LOGIN:
1206 return wtmpx_perform_login(li);
1207 case LTYPE_LOGOUT:
1208 return wtmpx_perform_logout(li);
1209 default:
1210 log("wtmpx_write_entry: invalid type field");
1211 return 0;
1212 }
andre61e67252000-06-04 17:07:49 +00001213}
andre2ff7b5d2000-06-03 14:57:40 +00001214
andre6bb92372000-06-19 08:20:03 +00001215/* Please see the notes above wtmp_islogin() for information about the
1216 next two functions */
1217
1218/* Return true if this wtmpx entry indicates a login */
1219static int
1220wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1221{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001222 if ( strncmp(li->username, utx->ut_name,
1223 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001224# ifdef HAVE_TYPE_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001225 if (utx->ut_type == USER_PROCESS)
1226 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001227# else
andre6bb92372000-06-19 08:20:03 +00001228 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001229# endif
andre6bb92372000-06-19 08:20:03 +00001230 }
1231 return 0;
1232}
1233
andre2ff7b5d2000-06-03 14:57:40 +00001234
1235int
andre61e67252000-06-04 17:07:49 +00001236wtmpx_get_entry(struct logininfo *li)
1237{
andre2ff7b5d2000-06-03 14:57:40 +00001238 struct stat st;
1239 struct utmpx utx;
andre6bb92372000-06-19 08:20:03 +00001240 int fd, found=0;
1241
1242 /* Clear the time entries */
1243 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001244
1245 if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1246 log("wtmpx_get_entry: problem opening %s: %s",
1247 WTMPX_FILE, strerror(errno));
1248 return 0;
1249 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001250 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001251 log("wtmpx_get_entry: couldn't stat %s: %s",
Tim Ricecdb82942002-07-14 15:33:20 -07001252 WTMPX_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001253 close(fd);
1254 return 0;
1255 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001256
andre6bb92372000-06-19 08:20:03 +00001257 /* Seek to the start of the last struct utmpx */
Kevin Steves52172652001-10-02 00:29:00 +00001258 if (lseek(fd, -(off_t)sizeof(struct utmpx), SEEK_END) == -1 ) {
andre6bb92372000-06-19 08:20:03 +00001259 /* probably a newly rotated wtmpx file */
1260 close(fd);
1261 return 0;
1262 }
andre2ff7b5d2000-06-03 14:57:40 +00001263
andre6bb92372000-06-19 08:20:03 +00001264 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001265 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001266 log("wtmpx_get_entry: read of %s failed: %s",
1267 WTMPX_FILE, strerror(errno));
1268 close (fd);
1269 return 0;
1270 }
andre2ff7b5d2000-06-03 14:57:40 +00001271 /* Logouts are recorded as a blank username on a particular line.
1272 * So, we just need to find the username in struct utmpx */
andre6bb92372000-06-19 08:20:03 +00001273 if ( wtmpx_islogin(li, &utx) ) {
Tim Rice370e0ba2002-07-14 15:50:51 -07001274 found = 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001275# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001276 li->tv_sec = utx.ut_tv.tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +10001277# else
andre2ff7b5d2000-06-03 14:57:40 +00001278# ifdef HAVE_TIME_IN_UTMPX
1279 li->tv_sec = utx.ut_time;
1280# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001281# endif
Damien Miller1a132252000-06-13 21:23:17 +10001282 line_fullname(li->line, utx.ut_line, sizeof(li->line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001283# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001284 strlcpy(li->hostname, utx.ut_host,
1285 MIN_SIZEOF(li->hostname, utx.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001286# endif
andre6bb92372000-06-19 08:20:03 +00001287 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001288 }
Kevin Steves52172652001-10-02 00:29:00 +00001289 if (lseek(fd, -(off_t)(2 * sizeof(struct utmpx)), SEEK_CUR) == -1) {
andre2ff7b5d2000-06-03 14:57:40 +00001290 close (fd);
1291 return 0;
1292 }
andre6bb92372000-06-19 08:20:03 +00001293 }
1294
1295 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001296 return 1;
andre61e67252000-06-04 17:07:49 +00001297}
Damien Millerd5bf3072000-06-07 21:32:13 +10001298#endif /* USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001299
andre2ff7b5d2000-06-03 14:57:40 +00001300/**
andre61e67252000-06-04 17:07:49 +00001301 ** Low-level libutil login() functions
andre2ff7b5d2000-06-03 14:57:40 +00001302 **/
1303
1304#ifdef USE_LOGIN
andre2ff7b5d2000-06-03 14:57:40 +00001305static int
andre61e67252000-06-04 17:07:49 +00001306syslogin_perform_login(struct logininfo *li)
1307{
andre2ff7b5d2000-06-03 14:57:40 +00001308 struct utmp *ut;
1309
Damien Miller348c9b72000-08-15 10:01:22 +10001310 if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
andre2ff7b5d2000-06-03 14:57:40 +00001311 log("syslogin_perform_login: couldn't malloc()");
1312 return 0;
1313 }
1314 construct_utmp(li, ut);
1315 login(ut);
1316
1317 return 1;
andre61e67252000-06-04 17:07:49 +00001318}
1319
andre2ff7b5d2000-06-03 14:57:40 +00001320static int
andre61e67252000-06-04 17:07:49 +00001321syslogin_perform_logout(struct logininfo *li)
1322{
Damien Millerdd47aa22000-06-27 11:18:27 +10001323# ifdef HAVE_LOGOUT
andre2ff7b5d2000-06-03 14:57:40 +00001324 char line[8];
Kevin Stevesef4eea92001-02-05 12:42:17 +00001325
andre2ff7b5d2000-06-03 14:57:40 +00001326 (void)line_stripname(line, li->line, sizeof(line));
1327
1328 if (!logout(line)) {
1329 log("syslogin_perform_logout: logout() returned an error");
Damien Millerdd47aa22000-06-27 11:18:27 +10001330# ifdef HAVE_LOGWTMP
andre2ff7b5d2000-06-03 14:57:40 +00001331 } else {
1332 logwtmp(line, "", "");
Damien Millerdd47aa22000-06-27 11:18:27 +10001333# endif
Damien Miller9b6d4ab2000-07-02 08:43:18 +10001334 }
andre6bb92372000-06-19 08:20:03 +00001335 /* FIXME: (ATL - if the need arises) What to do if we have
1336 * login, but no logout? what if logout but no logwtmp? All
1337 * routines are in libutil so they should all be there,
1338 * but... */
Damien Millerdd47aa22000-06-27 11:18:27 +10001339# endif
andre2ff7b5d2000-06-03 14:57:40 +00001340 return 1;
andre61e67252000-06-04 17:07:49 +00001341}
andre2ff7b5d2000-06-03 14:57:40 +00001342
andre2ff7b5d2000-06-03 14:57:40 +00001343int
andre61e67252000-06-04 17:07:49 +00001344syslogin_write_entry(struct logininfo *li)
1345{
andre2ff7b5d2000-06-03 14:57:40 +00001346 switch (li->type) {
1347 case LTYPE_LOGIN:
1348 return syslogin_perform_login(li);
1349 case LTYPE_LOGOUT:
1350 return syslogin_perform_logout(li);
1351 default:
1352 log("syslogin_write_entry: Invalid type field");
1353 return 0;
1354 }
andre61e67252000-06-04 17:07:49 +00001355}
Damien Millerd5bf3072000-06-07 21:32:13 +10001356#endif /* USE_LOGIN */
andre2ff7b5d2000-06-03 14:57:40 +00001357
1358/* end of file log-syslogin.c */
1359
andre2ff7b5d2000-06-03 14:57:40 +00001360/**
andre61e67252000-06-04 17:07:49 +00001361 ** Low-level lastlog functions
andre2ff7b5d2000-06-03 14:57:40 +00001362 **/
1363
1364#ifdef USE_LASTLOG
Damien Millerdd47aa22000-06-27 11:18:27 +10001365#define LL_FILE 1
1366#define LL_DIR 2
1367#define LL_OTHER 3
andre2ff7b5d2000-06-03 14:57:40 +00001368
andre2ff7b5d2000-06-03 14:57:40 +00001369static void
andre61e67252000-06-04 17:07:49 +00001370lastlog_construct(struct logininfo *li, struct lastlog *last)
1371{
andre2ff7b5d2000-06-03 14:57:40 +00001372 /* clear the structure */
Damien Miller348c9b72000-08-15 10:01:22 +10001373 memset(last, '\0', sizeof(*last));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001374
Damien Millerdd47aa22000-06-27 11:18:27 +10001375 (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
andre6bb92372000-06-19 08:20:03 +00001376 strlcpy(last->ll_host, li->hostname,
1377 MIN_SIZEOF(last->ll_host, li->hostname));
andre2ff7b5d2000-06-03 14:57:40 +00001378 last->ll_time = li->tv_sec;
andre61e67252000-06-04 17:07:49 +00001379}
andre2ff7b5d2000-06-03 14:57:40 +00001380
andre2ff7b5d2000-06-03 14:57:40 +00001381static int
andre61e67252000-06-04 17:07:49 +00001382lastlog_filetype(char *filename)
1383{
andre2ff7b5d2000-06-03 14:57:40 +00001384 struct stat st;
1385
Damien Millerdd47aa22000-06-27 11:18:27 +10001386 if (stat(LASTLOG_FILE, &st) != 0) {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001387 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
Damien Millerdd47aa22000-06-27 11:18:27 +10001388 strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001389 return 0;
1390 }
andre2ff7b5d2000-06-03 14:57:40 +00001391 if (S_ISDIR(st.st_mode))
1392 return LL_DIR;
1393 else if (S_ISREG(st.st_mode))
1394 return LL_FILE;
1395 else
1396 return LL_OTHER;
andre61e67252000-06-04 17:07:49 +00001397}
andre2ff7b5d2000-06-03 14:57:40 +00001398
1399
1400/* open the file (using filemode) and seek to the login entry */
1401static int
andre61e67252000-06-04 17:07:49 +00001402lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1403{
andre2ff7b5d2000-06-03 14:57:40 +00001404 off_t offset;
1405 int type;
1406 char lastlog_file[1024];
1407
1408 type = lastlog_filetype(LASTLOG_FILE);
1409 switch (type) {
Damien Millerf8af08d2000-06-27 09:40:06 +10001410 case LL_FILE:
1411 strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1412 break;
1413 case LL_DIR:
1414 snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1415 LASTLOG_FILE, li->username);
1416 break;
1417 default:
1418 log("lastlog_openseek: %.100s is not a file or directory!",
1419 LASTLOG_FILE);
1420 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001421 }
andre2ff7b5d2000-06-03 14:57:40 +00001422
1423 *fd = open(lastlog_file, filemode);
1424 if ( *fd < 0) {
Damien Miller53c5d462000-06-28 00:50:50 +10001425 debug("lastlog_openseek: Couldn't open %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001426 lastlog_file, strerror(errno));
1427 return 0;
1428 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001429
Damien Millere477ef62000-08-15 10:21:17 +10001430 if (type == LL_FILE) {
1431 /* find this uid's offset in the lastlog file */
Kevin Steves52172652001-10-02 00:29:00 +00001432 offset = (off_t) ((long)li->uid * sizeof(struct lastlog));
andre2ff7b5d2000-06-03 14:57:40 +00001433
Damien Millere477ef62000-08-15 10:21:17 +10001434 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1435 log("lastlog_openseek: %s->lseek(): %s",
Kevin Stevesef4eea92001-02-05 12:42:17 +00001436 lastlog_file, strerror(errno));
Damien Millere477ef62000-08-15 10:21:17 +10001437 return 0;
1438 }
andre2ff7b5d2000-06-03 14:57:40 +00001439 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001440
andre2ff7b5d2000-06-03 14:57:40 +00001441 return 1;
andre61e67252000-06-04 17:07:49 +00001442}
andre2ff7b5d2000-06-03 14:57:40 +00001443
1444static int
andre61e67252000-06-04 17:07:49 +00001445lastlog_perform_login(struct logininfo *li)
1446{
andre2ff7b5d2000-06-03 14:57:40 +00001447 struct lastlog last;
1448 int fd;
1449
1450 /* create our struct lastlog */
1451 lastlog_construct(li, &last);
1452
Damien Millerc1132e72000-08-18 14:08:38 +10001453 if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1454 return(0);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001455
andre2ff7b5d2000-06-03 14:57:40 +00001456 /* write the entry */
Damien Millerc1132e72000-08-18 14:08:38 +10001457 if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1458 close(fd);
1459 log("lastlog_write_filemode: Error writing to %s: %s",
1460 LASTLOG_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001461 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001462 }
Damien Millerc1132e72000-08-18 14:08:38 +10001463
1464 close(fd);
1465 return 1;
andre61e67252000-06-04 17:07:49 +00001466}
andre2ff7b5d2000-06-03 14:57:40 +00001467
andre2ff7b5d2000-06-03 14:57:40 +00001468int
andre61e67252000-06-04 17:07:49 +00001469lastlog_write_entry(struct logininfo *li)
1470{
andre2ff7b5d2000-06-03 14:57:40 +00001471 switch(li->type) {
1472 case LTYPE_LOGIN:
1473 return lastlog_perform_login(li);
1474 default:
1475 log("lastlog_write_entry: Invalid type field");
1476 return 0;
1477 }
andre61e67252000-06-04 17:07:49 +00001478}
andre2ff7b5d2000-06-03 14:57:40 +00001479
andre2ff7b5d2000-06-03 14:57:40 +00001480static void
andre61e67252000-06-04 17:07:49 +00001481lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1482{
andre2ff7b5d2000-06-03 14:57:40 +00001483 line_fullname(li->line, last->ll_line, sizeof(li->line));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001484 strlcpy(li->hostname, last->ll_host,
andre6bb92372000-06-19 08:20:03 +00001485 MIN_SIZEOF(li->hostname, last->ll_host));
andre2ff7b5d2000-06-03 14:57:40 +00001486 li->tv_sec = last->ll_time;
andre61e67252000-06-04 17:07:49 +00001487}
andre2ff7b5d2000-06-03 14:57:40 +00001488
andre2ff7b5d2000-06-03 14:57:40 +00001489int
andre61e67252000-06-04 17:07:49 +00001490lastlog_get_entry(struct logininfo *li)
1491{
andre2ff7b5d2000-06-03 14:57:40 +00001492 struct lastlog last;
1493 int fd;
1494
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001495 if (!lastlog_openseek(li, &fd, O_RDONLY))
1496 return 0;
1497
1498 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1499 close(fd);
1500 log("lastlog_get_entry: Error reading from %s: %s",
1501 LASTLOG_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001502 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001503 }
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001504
1505 close(fd);
1506
1507 lastlog_populate_entry(li, &last);
1508
1509 return 1;
andre61e67252000-06-04 17:07:49 +00001510}
Damien Millerd5bf3072000-06-07 21:32:13 +10001511#endif /* USE_LASTLOG */