blob: d7105ed7b64b00aad4f08463d53d29a39a7a97b7 [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 Riceb89e6942001-10-29 18:50:39 -0800166RCSID("$Id: loginrec.c,v 1.38 2001/10/30 02:50:40 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 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 Miller348c9b72000-08-15 10:01:22 +1000607 memset(ut, '\0', sizeof(*ut));
andre6bb92372000-06-19 08:20:03 +0000608
609 /* First fill out fields used for both logins and logouts */
610
Damien Millerdd47aa22000-06-27 11:18:27 +1000611# ifdef HAVE_ID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000612 line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000613# endif
andre2ff7b5d2000-06-03 14:57:40 +0000614
Damien Millerdd47aa22000-06-27 11:18:27 +1000615# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000616 /* This is done here to keep utmp constants out of struct logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000617 switch (li->type) {
618 case LTYPE_LOGIN:
619 ut->ut_type = USER_PROCESS;
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000620#ifdef _CRAY
621 cray_set_tmpdir(ut);
622#endif
andre2ff7b5d2000-06-03 14:57:40 +0000623 break;
624 case LTYPE_LOGOUT:
625 ut->ut_type = DEAD_PROCESS;
Ben Lindstrom6db66ff2001-08-06 23:29:16 +0000626#ifdef _CRAY
627 cray_retain_utmp(ut, li->pid);
628#endif
andre2ff7b5d2000-06-03 14:57:40 +0000629 break;
630 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000631# endif
andre6bb92372000-06-19 08:20:03 +0000632 set_utmp_time(li, ut);
andre2ff7b5d2000-06-03 14:57:40 +0000633
andre6bb92372000-06-19 08:20:03 +0000634 line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000635
636# ifdef HAVE_PID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000637 ut->ut_pid = li->pid;
Damien Millerdd47aa22000-06-27 11:18:27 +1000638# endif
andre6bb92372000-06-19 08:20:03 +0000639
640 /* If we're logging out, leave all other fields blank */
641 if (li->type == LTYPE_LOGOUT)
642 return;
643
Damien Millerdd47aa22000-06-27 11:18:27 +1000644 /*
645 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000646 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000647 */
andre6bb92372000-06-19 08:20:03 +0000648
649 /* Use strncpy because we don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000650 strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000651# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000652 strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000653# endif
654# ifdef HAVE_ADDR_IN_UTMP
andre61e67252000-06-04 17:07:49 +0000655 /* this is just a 32-bit IP address */
656 if (li->hostaddr.sa.sa_family == AF_INET)
657 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000658# endif
andre61e67252000-06-04 17:07:49 +0000659}
Damien Millerdd47aa22000-06-27 11:18:27 +1000660#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
andre61e67252000-06-04 17:07:49 +0000661
andre2ff7b5d2000-06-03 14:57:40 +0000662/**
663 ** utmpx utility functions
andre61e67252000-06-04 17:07:49 +0000664 **
665 ** These functions manipulate struct utmpx, accounting for system
666 ** variations.
andre2ff7b5d2000-06-03 14:57:40 +0000667 **/
668
669#if defined(USE_UTMPX) || defined (USE_WTMPX)
andre2ff7b5d2000-06-03 14:57:40 +0000670/* build the utmpx structure */
671void
andre61e67252000-06-04 17:07:49 +0000672set_utmpx_time(struct logininfo *li, struct utmpx *utx)
673{
Damien Millerdd47aa22000-06-27 11:18:27 +1000674# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000675 utx->ut_tv.tv_sec = li->tv_sec;
676 utx->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000677# else /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000678# ifdef HAVE_TIME_IN_UTMPX
679 utx->ut_time = li->tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000680# endif /* HAVE_TIME_IN_UTMPX */
681# endif /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000682}
683
andre61e67252000-06-04 17:07:49 +0000684void
685construct_utmpx(struct logininfo *li, struct utmpx *utx)
686{
Damien Miller348c9b72000-08-15 10:01:22 +1000687 memset(utx, '\0', sizeof(*utx));
Damien Miller8e81ed32000-07-01 13:17:42 +1000688# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000689 line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
Damien Miller8e81ed32000-07-01 13:17:42 +1000690# endif
andre2ff7b5d2000-06-03 14:57:40 +0000691
692 /* this is done here to keep utmp constants out of loginrec.h */
693 switch (li->type) {
694 case LTYPE_LOGIN:
695 utx->ut_type = USER_PROCESS;
696 break;
697 case LTYPE_LOGOUT:
698 utx->ut_type = DEAD_PROCESS;
699 break;
700 }
andre2ff7b5d2000-06-03 14:57:40 +0000701 line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
andre2ff7b5d2000-06-03 14:57:40 +0000702 set_utmpx_time(li, utx);
andre6bb92372000-06-19 08:20:03 +0000703 utx->ut_pid = li->pid;
704
705 if (li->type == LTYPE_LOGOUT)
706 return;
707
Damien Millerdd47aa22000-06-27 11:18:27 +1000708 /*
709 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000710 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000711 */
andre6bb92372000-06-19 08:20:03 +0000712
713 /* strncpy(): Don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000714 strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000715# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000716 strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000717# endif
718# ifdef HAVE_ADDR_IN_UTMPX
Damien Millerd6f204d2000-09-23 13:57:27 +1100719 /* this is just a 32-bit IP address */
720 if (li->hostaddr.sa.sa_family == AF_INET)
721 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Damien Millerdd47aa22000-06-27 11:18:27 +1000722# endif
723# ifdef HAVE_SYSLEN_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000724 /* ut_syslen is the length of the utx_host string */
725 utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +1000726# endif
andre61e67252000-06-04 17:07:49 +0000727}
Damien Millerdd47aa22000-06-27 11:18:27 +1000728#endif /* USE_UTMPX || USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000729
730/**
andre61e67252000-06-04 17:07:49 +0000731 ** Low-level utmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000732 **/
733
734/* FIXME: (ATL) utmp_write_direct needs testing */
andre2ff7b5d2000-06-03 14:57:40 +0000735#ifdef USE_UTMP
736
andre2ff7b5d2000-06-03 14:57:40 +0000737/* if we can, use pututline() etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000738# if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
739 defined(HAVE_PUTUTLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000740# define UTMP_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000741# endif
andre2ff7b5d2000-06-03 14:57:40 +0000742
743
744/* write a utmp entry with the system's help (pututline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000745# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000746static int
andre61e67252000-06-04 17:07:49 +0000747utmp_write_library(struct logininfo *li, struct utmp *ut)
748{
andre2ff7b5d2000-06-03 14:57:40 +0000749 setutent();
750 pututline(ut);
751
Damien Millerdd47aa22000-06-27 11:18:27 +1000752# ifdef HAVE_ENDUTENT
andre2ff7b5d2000-06-03 14:57:40 +0000753 endutent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000754# endif
andre2ff7b5d2000-06-03 14:57:40 +0000755 return 1;
andre61e67252000-06-04 17:07:49 +0000756}
Damien Millerdd47aa22000-06-27 11:18:27 +1000757# else /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000758
759/* write a utmp entry direct to the file */
andre61e67252000-06-04 17:07:49 +0000760/* This is a slightly modification of code in OpenBSD's login.c */
andre2ff7b5d2000-06-03 14:57:40 +0000761static int
andre61e67252000-06-04 17:07:49 +0000762utmp_write_direct(struct logininfo *li, struct utmp *ut)
763{
andre2ff7b5d2000-06-03 14:57:40 +0000764 struct utmp old_ut;
765 register int fd;
766 int tty;
767
andre6bb92372000-06-19 08:20:03 +0000768 /* FIXME: (ATL) ttyslot() needs local implementation */
Damien Miller348c9b72000-08-15 10:01:22 +1000769
Damien Millere5192fa2000-08-29 14:30:37 +1100770#if defined(HAVE_GETTTYENT)
Damien Miller348c9b72000-08-15 10:01:22 +1000771 register struct ttyent *ty;
772
773 tty=0;
774
775 setttyent();
776 while ((struct ttyent *)0 != (ty = getttyent())) {
777 tty++;
778 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
779 break;
780 }
781 endttyent();
782
783 if((struct ttyent *)0 == ty) {
784 log("utmp_write_entry: tty not found");
785 return(1);
786 }
787#else /* FIXME */
788
andre2ff7b5d2000-06-03 14:57:40 +0000789 tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
790
Damien Millere5192fa2000-08-29 14:30:37 +1100791#endif /* HAVE_GETTTYENT */
Damien Miller348c9b72000-08-15 10:01:22 +1000792
andre2ff7b5d2000-06-03 14:57:40 +0000793 if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
794 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
795 /*
796 * Prevent luser from zero'ing out ut_host.
797 * If the new ut_line is empty but the old one is not
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000798 * and ut_line and ut_name match, preserve the old ut_line.
andre2ff7b5d2000-06-03 14:57:40 +0000799 */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000800 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
801 (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
802 (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000803 (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
andre2ff7b5d2000-06-03 14:57:40 +0000804 (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
Damien Miller53c5d462000-06-28 00:50:50 +1000805 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000806
andre2ff7b5d2000-06-03 14:57:40 +0000807 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
Damien Miller36ccb5c2000-08-09 16:34:27 +1000808 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
andre2ff7b5d2000-06-03 14:57:40 +0000809 log("utmp_write_direct: error writing %s: %s",
andre6bb92372000-06-19 08:20:03 +0000810 UTMP_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000811
andre2ff7b5d2000-06-03 14:57:40 +0000812 (void)close(fd);
813 return 1;
Damien Miller53c5d462000-06-28 00:50:50 +1000814 } else {
andre2ff7b5d2000-06-03 14:57:40 +0000815 return 0;
Damien Miller53c5d462000-06-28 00:50:50 +1000816 }
andre61e67252000-06-04 17:07:49 +0000817}
Damien Millerdd47aa22000-06-27 11:18:27 +1000818# endif /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000819
820static int
andre61e67252000-06-04 17:07:49 +0000821utmp_perform_login(struct logininfo *li)
822{
andre2ff7b5d2000-06-03 14:57:40 +0000823 struct utmp ut;
824
825 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000826# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000827 if (!utmp_write_library(li, &ut)) {
andre6bb92372000-06-19 08:20:03 +0000828 log("utmp_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000829 return 0;
830 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000831# else
andre2ff7b5d2000-06-03 14:57:40 +0000832 if (!utmp_write_direct(li, &ut)) {
833 log("utmp_perform_login: utmp_write_direct() failed");
834 return 0;
835 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000836# endif
andre2ff7b5d2000-06-03 14:57:40 +0000837 return 1;
andre61e67252000-06-04 17:07:49 +0000838}
andre2ff7b5d2000-06-03 14:57:40 +0000839
840
841static int
andre61e67252000-06-04 17:07:49 +0000842utmp_perform_logout(struct logininfo *li)
843{
andre2ff7b5d2000-06-03 14:57:40 +0000844 struct utmp ut;
845
andre6bb92372000-06-19 08:20:03 +0000846 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000847# ifdef UTMP_USE_LIBRARY
andre6bb92372000-06-19 08:20:03 +0000848 if (!utmp_write_library(li, &ut)) {
849 log("utmp_perform_logout: utmp_write_library() failed");
850 return 0;
851 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000852# else
andre6bb92372000-06-19 08:20:03 +0000853 if (!utmp_write_direct(li, &ut)) {
854 log("utmp_perform_logout: utmp_write_direct() failed");
855 return 0;
856 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000857# endif
andre2ff7b5d2000-06-03 14:57:40 +0000858 return 1;
andre61e67252000-06-04 17:07:49 +0000859}
andre2ff7b5d2000-06-03 14:57:40 +0000860
861
862int
andre61e67252000-06-04 17:07:49 +0000863utmp_write_entry(struct logininfo *li)
864{
andre2ff7b5d2000-06-03 14:57:40 +0000865 switch(li->type) {
866 case LTYPE_LOGIN:
867 return utmp_perform_login(li);
868
869 case LTYPE_LOGOUT:
870 return utmp_perform_logout(li);
871
872 default:
873 log("utmp_write_entry: invalid type field");
874 return 0;
875 }
andre61e67252000-06-04 17:07:49 +0000876}
Damien Millerdd47aa22000-06-27 11:18:27 +1000877#endif /* USE_UTMP */
andre2ff7b5d2000-06-03 14:57:40 +0000878
879
880/**
andre61e67252000-06-04 17:07:49 +0000881 ** Low-level utmpx functions
andre2ff7b5d2000-06-03 14:57:40 +0000882 **/
883
884/* not much point if we don't want utmpx entries */
885#ifdef USE_UTMPX
886
andre2ff7b5d2000-06-03 14:57:40 +0000887/* if we have the wherewithall, use pututxline etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000888# if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
889 defined(HAVE_PUTUTXLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000890# define UTMPX_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000891# endif
andre2ff7b5d2000-06-03 14:57:40 +0000892
893
894/* write a utmpx entry with the system's help (pututxline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000895# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000896static int
andre61e67252000-06-04 17:07:49 +0000897utmpx_write_library(struct logininfo *li, struct utmpx *utx)
898{
andre2ff7b5d2000-06-03 14:57:40 +0000899 setutxent();
900 pututxline(utx);
901
Damien Millerdd47aa22000-06-27 11:18:27 +1000902# ifdef HAVE_ENDUTXENT
andre2ff7b5d2000-06-03 14:57:40 +0000903 endutxent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000904# endif
andre2ff7b5d2000-06-03 14:57:40 +0000905 return 1;
andre61e67252000-06-04 17:07:49 +0000906}
andre2ff7b5d2000-06-03 14:57:40 +0000907
Damien Millerdd47aa22000-06-27 11:18:27 +1000908# else /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000909
910/* write a utmp entry direct to the file */
911static int
andre61e67252000-06-04 17:07:49 +0000912utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000913{
andre2ff7b5d2000-06-03 14:57:40 +0000914 log("utmpx_write_direct: not implemented!");
915 return 0;
andre61e67252000-06-04 17:07:49 +0000916}
Damien Millerdd47aa22000-06-27 11:18:27 +1000917# endif /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000918
919static int
andre61e67252000-06-04 17:07:49 +0000920utmpx_perform_login(struct logininfo *li)
921{
andre2ff7b5d2000-06-03 14:57:40 +0000922 struct utmpx utx;
923
924 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000925# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000926 if (!utmpx_write_library(li, &utx)) {
927 log("utmpx_perform_login: utmp_write_library() failed");
928 return 0;
929 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000930# else
andre2ff7b5d2000-06-03 14:57:40 +0000931 if (!utmpx_write_direct(li, &ut)) {
932 log("utmpx_perform_login: utmp_write_direct() failed");
933 return 0;
934 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000935# endif
andre2ff7b5d2000-06-03 14:57:40 +0000936 return 1;
andre61e67252000-06-04 17:07:49 +0000937}
andre2ff7b5d2000-06-03 14:57:40 +0000938
939
940static int
andre61e67252000-06-04 17:07:49 +0000941utmpx_perform_logout(struct logininfo *li)
942{
andre2ff7b5d2000-06-03 14:57:40 +0000943 struct utmpx utx;
944
945 memset(&utx, '\0', sizeof(utx));
946 set_utmpx_time(li, &utx);
947 line_stripname(utx.ut_line, li->line, sizeof(utx.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000948# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000949 line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000950# endif
951# ifdef HAVE_TYPE_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000952 utx.ut_type = DEAD_PROCESS;
Damien Millerdd47aa22000-06-27 11:18:27 +1000953# endif
andre2ff7b5d2000-06-03 14:57:40 +0000954
Damien Millerdd47aa22000-06-27 11:18:27 +1000955# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000956 utmpx_write_library(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000957# else
andre2ff7b5d2000-06-03 14:57:40 +0000958 utmpx_write_direct(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000959# endif
andre2ff7b5d2000-06-03 14:57:40 +0000960 return 1;
andre61e67252000-06-04 17:07:49 +0000961}
andre2ff7b5d2000-06-03 14:57:40 +0000962
andre2ff7b5d2000-06-03 14:57:40 +0000963int
andre61e67252000-06-04 17:07:49 +0000964utmpx_write_entry(struct logininfo *li)
965{
andre2ff7b5d2000-06-03 14:57:40 +0000966 switch(li->type) {
967 case LTYPE_LOGIN:
968 return utmpx_perform_login(li);
969 case LTYPE_LOGOUT:
970 return utmpx_perform_logout(li);
971 default:
972 log("utmpx_write_entry: invalid type field");
973 return 0;
974 }
andre61e67252000-06-04 17:07:49 +0000975}
Damien Millerdd47aa22000-06-27 11:18:27 +1000976#endif /* USE_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000977
978
979/**
andre61e67252000-06-04 17:07:49 +0000980 ** Low-level wtmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000981 **/
982
Kevin Stevesef4eea92001-02-05 12:42:17 +0000983#ifdef USE_WTMP
andre2ff7b5d2000-06-03 14:57:40 +0000984
andre2ff7b5d2000-06-03 14:57:40 +0000985/* write a wtmp entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +0000986/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +0000987static int
andre61e67252000-06-04 17:07:49 +0000988wtmp_write(struct logininfo *li, struct utmp *ut)
989{
andre2ff7b5d2000-06-03 14:57:40 +0000990 struct stat buf;
991 int fd, ret = 1;
992
993 if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
994 log("wtmp_write: problem writing %s: %s",
995 WTMP_FILE, strerror(errno));
996 return 0;
997 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000998 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +1000999 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001000 ftruncate(fd, buf.st_size);
1001 log("wtmp_write: problem writing %s: %s",
1002 WTMP_FILE, strerror(errno));
1003 ret = 0;
1004 }
1005 (void)close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001006 return ret;
andre61e67252000-06-04 17:07:49 +00001007}
andre2ff7b5d2000-06-03 14:57:40 +00001008
andre2ff7b5d2000-06-03 14:57:40 +00001009static int
Damien Millerdd47aa22000-06-27 11:18:27 +10001010wtmp_perform_login(struct logininfo *li)
1011{
andre2ff7b5d2000-06-03 14:57:40 +00001012 struct utmp ut;
1013
1014 construct_utmp(li, &ut);
1015 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001016}
andre2ff7b5d2000-06-03 14:57:40 +00001017
1018
1019static int
andre61e67252000-06-04 17:07:49 +00001020wtmp_perform_logout(struct logininfo *li)
1021{
andre2ff7b5d2000-06-03 14:57:40 +00001022 struct utmp ut;
1023
1024 construct_utmp(li, &ut);
andre2ff7b5d2000-06-03 14:57:40 +00001025 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001026}
andre2ff7b5d2000-06-03 14:57:40 +00001027
1028
1029int
andre61e67252000-06-04 17:07:49 +00001030wtmp_write_entry(struct logininfo *li)
1031{
andre2ff7b5d2000-06-03 14:57:40 +00001032 switch(li->type) {
1033 case LTYPE_LOGIN:
1034 return wtmp_perform_login(li);
1035 case LTYPE_LOGOUT:
1036 return wtmp_perform_logout(li);
1037 default:
1038 log("wtmp_write_entry: invalid type field");
1039 return 0;
1040 }
andre61e67252000-06-04 17:07:49 +00001041}
andre2ff7b5d2000-06-03 14:57:40 +00001042
1043
andre6bb92372000-06-19 08:20:03 +00001044/* Notes on fetching login data from wtmp/wtmpx
Kevin Stevesef4eea92001-02-05 12:42:17 +00001045 *
andre6bb92372000-06-19 08:20:03 +00001046 * Logouts are usually recorded with (amongst other things) a blank
1047 * username on a given tty line. However, some systems (HP-UX is one)
1048 * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1049 *
1050 * Since we're only looking for logins here, we know that the username
1051 * must be set correctly. On systems that leave it in, we check for
1052 * ut_type==USER_PROCESS (indicating a login.)
1053 *
1054 * Portability: Some systems may set something other than USER_PROCESS
1055 * to indicate a login process. I don't know of any as I write. Also,
1056 * it's possible that some systems may both leave the username in
1057 * place and not have ut_type.
1058 */
1059
andre6bb92372000-06-19 08:20:03 +00001060/* return true if this wtmp entry indicates a login */
1061static int
1062wtmp_islogin(struct logininfo *li, struct utmp *ut)
1063{
Kevin Stevesef4eea92001-02-05 12:42:17 +00001064 if (strncmp(li->username, ut->ut_name,
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001065 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001066# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001067 if (ut->ut_type & USER_PROCESS)
1068 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001069# else
andre6bb92372000-06-19 08:20:03 +00001070 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001071# endif
andre6bb92372000-06-19 08:20:03 +00001072 }
1073 return 0;
1074}
1075
andre2ff7b5d2000-06-03 14:57:40 +00001076int
andre61e67252000-06-04 17:07:49 +00001077wtmp_get_entry(struct logininfo *li)
1078{
andre2ff7b5d2000-06-03 14:57:40 +00001079 struct stat st;
1080 struct utmp ut;
andre6bb92372000-06-19 08:20:03 +00001081 int fd, found=0;
1082
1083 /* Clear the time entries in our logininfo */
1084 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001085
1086 if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1087 log("wtmp_get_entry: problem opening %s: %s",
1088 WTMP_FILE, strerror(errno));
1089 return 0;
1090 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001091 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001092 log("wtmp_get_entry: couldn't stat %s: %s",
1093 WTMP_FILE, strerror(errno));
1094 close(fd);
1095 return 0;
1096 }
andre2ff7b5d2000-06-03 14:57:40 +00001097
andre6bb92372000-06-19 08:20:03 +00001098 /* Seek to the start of the last struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001099 if (lseek(fd, -(off_t)sizeof(struct utmp), SEEK_END) == -1) {
andre6bb92372000-06-19 08:20:03 +00001100 /* Looks like we've got a fresh wtmp file */
1101 close(fd);
1102 return 0;
1103 }
1104
1105 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001106 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001107 log("wtmp_get_entry: read of %s failed: %s",
1108 WTMP_FILE, strerror(errno));
1109 close (fd);
1110 return 0;
1111 }
andre6bb92372000-06-19 08:20:03 +00001112 if ( wtmp_islogin(li, &ut) ) {
1113 found = 1;
1114 /* We've already checked for a time in struct
1115 * utmp, in login_getlast(). */
Damien Millerdd47aa22000-06-27 11:18:27 +10001116# ifdef HAVE_TIME_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +00001117 li->tv_sec = ut.ut_time;
Damien Millerdd47aa22000-06-27 11:18:27 +10001118# else
andre2ff7b5d2000-06-03 14:57:40 +00001119# if HAVE_TV_IN_UTMP
1120 li->tv_sec = ut.ut_tv.tv_sec;
1121# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001122# endif
andre6bb92372000-06-19 08:20:03 +00001123 line_fullname(li->line, ut.ut_line,
1124 MIN_SIZEOF(li->line, ut.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001125# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001126 strlcpy(li->hostname, ut.ut_host,
1127 MIN_SIZEOF(li->hostname, ut.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001128# endif
andre6bb92372000-06-19 08:20:03 +00001129 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001130 }
andre6bb92372000-06-19 08:20:03 +00001131 /* Seek back 2 x struct utmp */
Kevin Steves52172652001-10-02 00:29:00 +00001132 if (lseek(fd, -(off_t)(2 * sizeof(struct utmp)), SEEK_CUR) == -1) {
andre6bb92372000-06-19 08:20:03 +00001133 /* We've found the start of the file, so quit */
andre2ff7b5d2000-06-03 14:57:40 +00001134 close (fd);
1135 return 0;
1136 }
andre6bb92372000-06-19 08:20:03 +00001137 }
1138
1139 /* We found an entry. Tidy up and return */
1140 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001141 return 1;
andre61e67252000-06-04 17:07:49 +00001142}
Damien Millerdd47aa22000-06-27 11:18:27 +10001143# endif /* USE_WTMP */
andre2ff7b5d2000-06-03 14:57:40 +00001144
1145
1146/**
andre61e67252000-06-04 17:07:49 +00001147 ** Low-level wtmpx functions
andre2ff7b5d2000-06-03 14:57:40 +00001148 **/
1149
1150#ifdef USE_WTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001151/* write a wtmpx entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001152/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001153static int
andre61e67252000-06-04 17:07:49 +00001154wtmpx_write(struct logininfo *li, struct utmpx *utx)
1155{
andre2ff7b5d2000-06-03 14:57:40 +00001156 struct stat buf;
1157 int fd, ret = 1;
1158
1159 if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1160 log("wtmpx_write: problem opening %s: %s",
1161 WTMPX_FILE, strerror(errno));
1162 return 0;
1163 }
1164
Kevin Stevesef4eea92001-02-05 12:42:17 +00001165 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001166 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001167 ftruncate(fd, buf.st_size);
1168 log("wtmpx_write: problem writing %s: %s",
1169 WTMPX_FILE, strerror(errno));
1170 ret = 0;
1171 }
1172 (void)close(fd);
1173
1174 return ret;
andre61e67252000-06-04 17:07:49 +00001175}
andre2ff7b5d2000-06-03 14:57:40 +00001176
1177
1178static int
andre61e67252000-06-04 17:07:49 +00001179wtmpx_perform_login(struct logininfo *li)
1180{
andre2ff7b5d2000-06-03 14:57:40 +00001181 struct utmpx utx;
1182
1183 construct_utmpx(li, &utx);
1184 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001185}
andre2ff7b5d2000-06-03 14:57:40 +00001186
1187
1188static int
andre61e67252000-06-04 17:07:49 +00001189wtmpx_perform_logout(struct logininfo *li)
1190{
andre2ff7b5d2000-06-03 14:57:40 +00001191 struct utmpx utx;
1192
1193 construct_utmpx(li, &utx);
andre2ff7b5d2000-06-03 14:57:40 +00001194 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001195}
andre2ff7b5d2000-06-03 14:57:40 +00001196
1197
1198int
andre61e67252000-06-04 17:07:49 +00001199wtmpx_write_entry(struct logininfo *li)
1200{
andre2ff7b5d2000-06-03 14:57:40 +00001201 switch(li->type) {
1202 case LTYPE_LOGIN:
1203 return wtmpx_perform_login(li);
1204 case LTYPE_LOGOUT:
1205 return wtmpx_perform_logout(li);
1206 default:
1207 log("wtmpx_write_entry: invalid type field");
1208 return 0;
1209 }
andre61e67252000-06-04 17:07:49 +00001210}
andre2ff7b5d2000-06-03 14:57:40 +00001211
andre6bb92372000-06-19 08:20:03 +00001212/* Please see the notes above wtmp_islogin() for information about the
1213 next two functions */
1214
1215/* Return true if this wtmpx entry indicates a login */
1216static int
1217wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1218{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001219 if ( strncmp(li->username, utx->ut_name,
1220 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001221# ifdef HAVE_TYPE_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001222 if (utx->ut_type == USER_PROCESS)
1223 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001224# else
andre6bb92372000-06-19 08:20:03 +00001225 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001226# endif
andre6bb92372000-06-19 08:20:03 +00001227 }
1228 return 0;
1229}
1230
andre2ff7b5d2000-06-03 14:57:40 +00001231
1232int
andre61e67252000-06-04 17:07:49 +00001233wtmpx_get_entry(struct logininfo *li)
1234{
andre2ff7b5d2000-06-03 14:57:40 +00001235 struct stat st;
1236 struct utmpx utx;
andre6bb92372000-06-19 08:20:03 +00001237 int fd, found=0;
1238
1239 /* Clear the time entries */
1240 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001241
1242 if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1243 log("wtmpx_get_entry: problem opening %s: %s",
1244 WTMPX_FILE, strerror(errno));
1245 return 0;
1246 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001247 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001248 log("wtmpx_get_entry: couldn't stat %s: %s",
1249 WTMP_FILE, strerror(errno));
1250 close(fd);
1251 return 0;
1252 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001253
andre6bb92372000-06-19 08:20:03 +00001254 /* Seek to the start of the last struct utmpx */
Kevin Steves52172652001-10-02 00:29:00 +00001255 if (lseek(fd, -(off_t)sizeof(struct utmpx), SEEK_END) == -1 ) {
andre6bb92372000-06-19 08:20:03 +00001256 /* probably a newly rotated wtmpx file */
1257 close(fd);
1258 return 0;
1259 }
andre2ff7b5d2000-06-03 14:57:40 +00001260
andre6bb92372000-06-19 08:20:03 +00001261 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001262 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001263 log("wtmpx_get_entry: read of %s failed: %s",
1264 WTMPX_FILE, strerror(errno));
1265 close (fd);
1266 return 0;
1267 }
andre2ff7b5d2000-06-03 14:57:40 +00001268 /* Logouts are recorded as a blank username on a particular line.
1269 * So, we just need to find the username in struct utmpx */
andre6bb92372000-06-19 08:20:03 +00001270 if ( wtmpx_islogin(li, &utx) ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001271# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001272 li->tv_sec = utx.ut_tv.tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +10001273# else
andre2ff7b5d2000-06-03 14:57:40 +00001274# ifdef HAVE_TIME_IN_UTMPX
1275 li->tv_sec = utx.ut_time;
1276# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001277# endif
Damien Miller1a132252000-06-13 21:23:17 +10001278 line_fullname(li->line, utx.ut_line, sizeof(li->line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001279# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001280 strlcpy(li->hostname, utx.ut_host,
1281 MIN_SIZEOF(li->hostname, utx.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001282# endif
andre6bb92372000-06-19 08:20:03 +00001283 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001284 }
Kevin Steves52172652001-10-02 00:29:00 +00001285 if (lseek(fd, -(off_t)(2 * sizeof(struct utmpx)), SEEK_CUR) == -1) {
andre2ff7b5d2000-06-03 14:57:40 +00001286 close (fd);
1287 return 0;
1288 }
andre6bb92372000-06-19 08:20:03 +00001289 }
1290
1291 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001292 return 1;
andre61e67252000-06-04 17:07:49 +00001293}
Damien Millerd5bf3072000-06-07 21:32:13 +10001294#endif /* USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001295
andre2ff7b5d2000-06-03 14:57:40 +00001296/**
andre61e67252000-06-04 17:07:49 +00001297 ** Low-level libutil login() functions
andre2ff7b5d2000-06-03 14:57:40 +00001298 **/
1299
1300#ifdef USE_LOGIN
andre2ff7b5d2000-06-03 14:57:40 +00001301static int
andre61e67252000-06-04 17:07:49 +00001302syslogin_perform_login(struct logininfo *li)
1303{
andre2ff7b5d2000-06-03 14:57:40 +00001304 struct utmp *ut;
1305
Damien Miller348c9b72000-08-15 10:01:22 +10001306 if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
andre2ff7b5d2000-06-03 14:57:40 +00001307 log("syslogin_perform_login: couldn't malloc()");
1308 return 0;
1309 }
1310 construct_utmp(li, ut);
1311 login(ut);
1312
1313 return 1;
andre61e67252000-06-04 17:07:49 +00001314}
1315
andre2ff7b5d2000-06-03 14:57:40 +00001316static int
andre61e67252000-06-04 17:07:49 +00001317syslogin_perform_logout(struct logininfo *li)
1318{
Damien Millerdd47aa22000-06-27 11:18:27 +10001319# ifdef HAVE_LOGOUT
andre2ff7b5d2000-06-03 14:57:40 +00001320 char line[8];
Kevin Stevesef4eea92001-02-05 12:42:17 +00001321
andre2ff7b5d2000-06-03 14:57:40 +00001322 (void)line_stripname(line, li->line, sizeof(line));
1323
1324 if (!logout(line)) {
1325 log("syslogin_perform_logout: logout() returned an error");
Damien Millerdd47aa22000-06-27 11:18:27 +10001326# ifdef HAVE_LOGWTMP
andre2ff7b5d2000-06-03 14:57:40 +00001327 } else {
1328 logwtmp(line, "", "");
Damien Millerdd47aa22000-06-27 11:18:27 +10001329# endif
Damien Miller9b6d4ab2000-07-02 08:43:18 +10001330 }
andre6bb92372000-06-19 08:20:03 +00001331 /* FIXME: (ATL - if the need arises) What to do if we have
1332 * login, but no logout? what if logout but no logwtmp? All
1333 * routines are in libutil so they should all be there,
1334 * but... */
Damien Millerdd47aa22000-06-27 11:18:27 +10001335# endif
andre2ff7b5d2000-06-03 14:57:40 +00001336 return 1;
andre61e67252000-06-04 17:07:49 +00001337}
andre2ff7b5d2000-06-03 14:57:40 +00001338
andre2ff7b5d2000-06-03 14:57:40 +00001339int
andre61e67252000-06-04 17:07:49 +00001340syslogin_write_entry(struct logininfo *li)
1341{
andre2ff7b5d2000-06-03 14:57:40 +00001342 switch (li->type) {
1343 case LTYPE_LOGIN:
1344 return syslogin_perform_login(li);
1345 case LTYPE_LOGOUT:
1346 return syslogin_perform_logout(li);
1347 default:
1348 log("syslogin_write_entry: Invalid type field");
1349 return 0;
1350 }
andre61e67252000-06-04 17:07:49 +00001351}
Damien Millerd5bf3072000-06-07 21:32:13 +10001352#endif /* USE_LOGIN */
andre2ff7b5d2000-06-03 14:57:40 +00001353
1354/* end of file log-syslogin.c */
1355
andre2ff7b5d2000-06-03 14:57:40 +00001356/**
andre61e67252000-06-04 17:07:49 +00001357 ** Low-level lastlog functions
andre2ff7b5d2000-06-03 14:57:40 +00001358 **/
1359
1360#ifdef USE_LASTLOG
Damien Millerdd47aa22000-06-27 11:18:27 +10001361#define LL_FILE 1
1362#define LL_DIR 2
1363#define LL_OTHER 3
andre2ff7b5d2000-06-03 14:57:40 +00001364
andre2ff7b5d2000-06-03 14:57:40 +00001365static void
andre61e67252000-06-04 17:07:49 +00001366lastlog_construct(struct logininfo *li, struct lastlog *last)
1367{
andre2ff7b5d2000-06-03 14:57:40 +00001368 /* clear the structure */
Damien Miller348c9b72000-08-15 10:01:22 +10001369 memset(last, '\0', sizeof(*last));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001370
Damien Millerdd47aa22000-06-27 11:18:27 +10001371 (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
andre6bb92372000-06-19 08:20:03 +00001372 strlcpy(last->ll_host, li->hostname,
1373 MIN_SIZEOF(last->ll_host, li->hostname));
andre2ff7b5d2000-06-03 14:57:40 +00001374 last->ll_time = li->tv_sec;
andre61e67252000-06-04 17:07:49 +00001375}
andre2ff7b5d2000-06-03 14:57:40 +00001376
andre2ff7b5d2000-06-03 14:57:40 +00001377static int
andre61e67252000-06-04 17:07:49 +00001378lastlog_filetype(char *filename)
1379{
andre2ff7b5d2000-06-03 14:57:40 +00001380 struct stat st;
1381
Damien Millerdd47aa22000-06-27 11:18:27 +10001382 if (stat(LASTLOG_FILE, &st) != 0) {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001383 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
Damien Millerdd47aa22000-06-27 11:18:27 +10001384 strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001385 return 0;
1386 }
andre2ff7b5d2000-06-03 14:57:40 +00001387 if (S_ISDIR(st.st_mode))
1388 return LL_DIR;
1389 else if (S_ISREG(st.st_mode))
1390 return LL_FILE;
1391 else
1392 return LL_OTHER;
andre61e67252000-06-04 17:07:49 +00001393}
andre2ff7b5d2000-06-03 14:57:40 +00001394
1395
1396/* open the file (using filemode) and seek to the login entry */
1397static int
andre61e67252000-06-04 17:07:49 +00001398lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1399{
andre2ff7b5d2000-06-03 14:57:40 +00001400 off_t offset;
1401 int type;
1402 char lastlog_file[1024];
1403
1404 type = lastlog_filetype(LASTLOG_FILE);
1405 switch (type) {
Damien Millerf8af08d2000-06-27 09:40:06 +10001406 case LL_FILE:
1407 strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1408 break;
1409 case LL_DIR:
1410 snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1411 LASTLOG_FILE, li->username);
1412 break;
1413 default:
1414 log("lastlog_openseek: %.100s is not a file or directory!",
1415 LASTLOG_FILE);
1416 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001417 }
andre2ff7b5d2000-06-03 14:57:40 +00001418
1419 *fd = open(lastlog_file, filemode);
1420 if ( *fd < 0) {
Damien Miller53c5d462000-06-28 00:50:50 +10001421 debug("lastlog_openseek: Couldn't open %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001422 lastlog_file, strerror(errno));
1423 return 0;
1424 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001425
Damien Millere477ef62000-08-15 10:21:17 +10001426 if (type == LL_FILE) {
1427 /* find this uid's offset in the lastlog file */
Kevin Steves52172652001-10-02 00:29:00 +00001428 offset = (off_t) ((long)li->uid * sizeof(struct lastlog));
andre2ff7b5d2000-06-03 14:57:40 +00001429
Damien Millere477ef62000-08-15 10:21:17 +10001430 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1431 log("lastlog_openseek: %s->lseek(): %s",
Kevin Stevesef4eea92001-02-05 12:42:17 +00001432 lastlog_file, strerror(errno));
Damien Millere477ef62000-08-15 10:21:17 +10001433 return 0;
1434 }
andre2ff7b5d2000-06-03 14:57:40 +00001435 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001436
andre2ff7b5d2000-06-03 14:57:40 +00001437 return 1;
andre61e67252000-06-04 17:07:49 +00001438}
andre2ff7b5d2000-06-03 14:57:40 +00001439
1440static int
andre61e67252000-06-04 17:07:49 +00001441lastlog_perform_login(struct logininfo *li)
1442{
andre2ff7b5d2000-06-03 14:57:40 +00001443 struct lastlog last;
1444 int fd;
1445
1446 /* create our struct lastlog */
1447 lastlog_construct(li, &last);
1448
Damien Millerc1132e72000-08-18 14:08:38 +10001449 if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1450 return(0);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001451
andre2ff7b5d2000-06-03 14:57:40 +00001452 /* write the entry */
Damien Millerc1132e72000-08-18 14:08:38 +10001453 if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1454 close(fd);
1455 log("lastlog_write_filemode: Error writing to %s: %s",
1456 LASTLOG_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001457 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001458 }
Damien Millerc1132e72000-08-18 14:08:38 +10001459
1460 close(fd);
1461 return 1;
andre61e67252000-06-04 17:07:49 +00001462}
andre2ff7b5d2000-06-03 14:57:40 +00001463
andre2ff7b5d2000-06-03 14:57:40 +00001464int
andre61e67252000-06-04 17:07:49 +00001465lastlog_write_entry(struct logininfo *li)
1466{
andre2ff7b5d2000-06-03 14:57:40 +00001467 switch(li->type) {
1468 case LTYPE_LOGIN:
1469 return lastlog_perform_login(li);
1470 default:
1471 log("lastlog_write_entry: Invalid type field");
1472 return 0;
1473 }
andre61e67252000-06-04 17:07:49 +00001474}
andre2ff7b5d2000-06-03 14:57:40 +00001475
andre2ff7b5d2000-06-03 14:57:40 +00001476static void
andre61e67252000-06-04 17:07:49 +00001477lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1478{
andre2ff7b5d2000-06-03 14:57:40 +00001479 line_fullname(li->line, last->ll_line, sizeof(li->line));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001480 strlcpy(li->hostname, last->ll_host,
andre6bb92372000-06-19 08:20:03 +00001481 MIN_SIZEOF(li->hostname, last->ll_host));
andre2ff7b5d2000-06-03 14:57:40 +00001482 li->tv_sec = last->ll_time;
andre61e67252000-06-04 17:07:49 +00001483}
andre2ff7b5d2000-06-03 14:57:40 +00001484
andre2ff7b5d2000-06-03 14:57:40 +00001485int
andre61e67252000-06-04 17:07:49 +00001486lastlog_get_entry(struct logininfo *li)
1487{
andre2ff7b5d2000-06-03 14:57:40 +00001488 struct lastlog last;
1489 int fd;
1490
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001491 if (!lastlog_openseek(li, &fd, O_RDONLY))
1492 return 0;
1493
1494 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1495 close(fd);
1496 log("lastlog_get_entry: Error reading from %s: %s",
1497 LASTLOG_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001498 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001499 }
Damien Miller3a8a5cd2001-10-22 16:49:22 +10001500
1501 close(fd);
1502
1503 lastlog_populate_entry(li, &last);
1504
1505 return 1;
andre61e67252000-06-04 17:07:49 +00001506}
Damien Millerd5bf3072000-06-07 21:32:13 +10001507#endif /* USE_LASTLOG */