blob: e121ce354fba1f91cf9bdfed705b252e2979fd78 [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
126 configure.in and loginrec.c. (You have to build logintest yourself
127 with 'make logintest' as it's not built by default.)
128
129 Otherwise, patches to the specific method(s) are very helpful!
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
Ben Lindstrom97c677d2001-05-08 20:33:05 +0000166RCSID("$Id: loginrec.c,v 1.33 2001/05/08 20:33:06 mouring 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;
451# ifdef USE_UTMP
452 utmp_write_entry(li);
453# endif
454# ifdef USE_WTMP
455 wtmp_write_entry(li);
456# endif
457# ifdef USE_UTMPX
458 utmpx_write_entry(li);
459# endif
460# ifdef USE_WTMPX
461 wtmpx_write_entry(li);
462# endif
463 return 0;
464}
465#endif
466
andre2ff7b5d2000-06-03 14:57:40 +0000467/**
andre61e67252000-06-04 17:07:49 +0000468 ** getlast_entry: Call low-level functions to retrieve the last login
469 ** time.
andre2ff7b5d2000-06-03 14:57:40 +0000470 **/
471
andre61e67252000-06-04 17:07:49 +0000472/* take the uid in li and return the last login time */
473int
474getlast_entry(struct logininfo *li)
475{
476#ifdef USE_LASTLOG
Damien Miller53c5d462000-06-28 00:50:50 +1000477 return(lastlog_get_entry(li));
Damien Millerdd47aa22000-06-27 11:18:27 +1000478#else /* !USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000479
Damien Millerdd47aa22000-06-27 11:18:27 +1000480#ifdef DISABLE_LASTLOG
Kevin Stevesef4eea92001-02-05 12:42:17 +0000481 /* On some systems we shouldn't even try to obtain last login
andreecaabf12000-06-12 22:21:44 +0000482 * time, e.g. AIX */
483 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000484# else /* DISABLE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000485 /* Try to retrieve the last login time from wtmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000486# if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
andre61e67252000-06-04 17:07:49 +0000487 /* retrieve last login time from utmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000488 return (wtmp_get_entry(li));
489# else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
andre61e67252000-06-04 17:07:49 +0000490 /* If wtmp isn't available, try wtmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000491# if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
andre61e67252000-06-04 17:07:49 +0000492 /* retrieve last login time from utmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000493 return (wtmpx_get_entry(li));
494# else
andre61e67252000-06-04 17:07:49 +0000495 /* Give up: No means of retrieving last login time */
496 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000497# endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
498# endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000499# endif /* DISABLE_LASTLOG */
Damien Millerdd47aa22000-06-27 11:18:27 +1000500#endif /* USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000501}
502
503
504
andre2ff7b5d2000-06-03 14:57:40 +0000505/*
andre61e67252000-06-04 17:07:49 +0000506 * 'line' string utility functions
507 *
508 * These functions process the 'line' string into one of three forms:
509 *
andre2ff7b5d2000-06-03 14:57:40 +0000510 * 1. The full filename (including '/dev')
511 * 2. The stripped name (excluding '/dev')
andre61e67252000-06-04 17:07:49 +0000512 * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
513 * /dev/pts/1 -> ts/1 )
andre2ff7b5d2000-06-03 14:57:40 +0000514 *
515 * Form 3 is used on some systems to identify a .tmp.? entry when
516 * attempting to remove it. Typically both addition and removal is
andre61e67252000-06-04 17:07:49 +0000517 * performed by one application - say, sshd - so as long as the choice
518 * uniquely identifies a terminal it's ok.
andre2ff7b5d2000-06-03 14:57:40 +0000519 */
520
521
andre61e67252000-06-04 17:07:49 +0000522/* line_fullname(): add the leading '/dev/' if it doesn't exist make
523 * sure dst has enough space, if not just copy src (ugh) */
andre2ff7b5d2000-06-03 14:57:40 +0000524char *
andre61e67252000-06-04 17:07:49 +0000525line_fullname(char *dst, const char *src, int dstsize)
526{
andre2ff7b5d2000-06-03 14:57:40 +0000527 memset(dst, '\0', dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100528 if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
andre2ff7b5d2000-06-03 14:57:40 +0000529 strlcpy(dst, src, dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100530 } else {
Damien Miller1a132252000-06-13 21:23:17 +1000531 strlcpy(dst, "/dev/", dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000532 strlcat(dst, src, dstsize);
533 }
534 return dst;
535}
536
andre61e67252000-06-04 17:07:49 +0000537/* line_stripname(): strip the leading '/dev' if it exists, return dst */
andre2ff7b5d2000-06-03 14:57:40 +0000538char *
andre61e67252000-06-04 17:07:49 +0000539line_stripname(char *dst, const char *src, int dstsize)
540{
andre2ff7b5d2000-06-03 14:57:40 +0000541 memset(dst, '\0', dstsize);
542 if (strncmp(src, "/dev/", 5) == 0)
Damien Millerf5a81472000-09-30 21:34:44 +1100543 strlcpy(dst, src + 5, dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000544 else
545 strlcpy(dst, src, dstsize);
546 return dst;
andre61e67252000-06-04 17:07:49 +0000547}
548
andre61e67252000-06-04 17:07:49 +0000549/* line_abbrevname(): Return the abbreviated (usually four-character)
550 * form of the line (Just use the last <dstsize> characters of the
551 * full name.)
552 *
553 * NOTE: use strncpy because we do NOT necessarily want zero
554 * termination */
andre2ff7b5d2000-06-03 14:57:40 +0000555char *
Kevin Stevesef4eea92001-02-05 12:42:17 +0000556line_abbrevname(char *dst, const char *src, int dstsize)
Damien Millerdd47aa22000-06-27 11:18:27 +1000557{
558 size_t len;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000559
andre2ff7b5d2000-06-03 14:57:40 +0000560 memset(dst, '\0', dstsize);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000561
Damien Miller8e81ed32000-07-01 13:17:42 +1000562 /* Always skip prefix if present */
563 if (strncmp(src, "/dev/", 5) == 0)
564 src += 5;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000565
Damien Millerdd47aa22000-06-27 11:18:27 +1000566 len = strlen(src);
567
Damien Miller8e81ed32000-07-01 13:17:42 +1000568 if (len > 0) {
569 if (((int)len - dstsize) > 0)
570 src += ((int)len - dstsize);
571
572 /* note: _don't_ change this to strlcpy */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000573 strncpy(dst, src, (size_t)dstsize);
Damien Millerdd47aa22000-06-27 11:18:27 +1000574 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000575
andre2ff7b5d2000-06-03 14:57:40 +0000576 return dst;
577}
578
andre2ff7b5d2000-06-03 14:57:40 +0000579/**
580 ** utmp utility functions
andre61e67252000-06-04 17:07:49 +0000581 **
582 ** These functions manipulate struct utmp, taking system differences
583 ** into account.
andre2ff7b5d2000-06-03 14:57:40 +0000584 **/
585
586#if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
587
andre2ff7b5d2000-06-03 14:57:40 +0000588/* build the utmp structure */
589void
andre61e67252000-06-04 17:07:49 +0000590set_utmp_time(struct logininfo *li, struct utmp *ut)
591{
Damien Millerdd47aa22000-06-27 11:18:27 +1000592# ifdef HAVE_TV_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000593 ut->ut_tv.tv_sec = li->tv_sec;
594 ut->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000595# else
andre2ff7b5d2000-06-03 14:57:40 +0000596# ifdef HAVE_TIME_IN_UTMP
597 ut->ut_time = li->tv_sec;
598# endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000599# endif
andre2ff7b5d2000-06-03 14:57:40 +0000600}
601
602void
603construct_utmp(struct logininfo *li,
andre61e67252000-06-04 17:07:49 +0000604 struct utmp *ut)
605{
Damien Miller348c9b72000-08-15 10:01:22 +1000606 memset(ut, '\0', sizeof(*ut));
andre6bb92372000-06-19 08:20:03 +0000607
608 /* First fill out fields used for both logins and logouts */
609
Damien Millerdd47aa22000-06-27 11:18:27 +1000610# ifdef HAVE_ID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000611 line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000612# endif
andre2ff7b5d2000-06-03 14:57:40 +0000613
Damien Millerdd47aa22000-06-27 11:18:27 +1000614# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000615 /* This is done here to keep utmp constants out of struct logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000616 switch (li->type) {
617 case LTYPE_LOGIN:
618 ut->ut_type = USER_PROCESS;
619 break;
620 case LTYPE_LOGOUT:
621 ut->ut_type = DEAD_PROCESS;
622 break;
623 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000624# endif
andre6bb92372000-06-19 08:20:03 +0000625 set_utmp_time(li, ut);
andre2ff7b5d2000-06-03 14:57:40 +0000626
andre6bb92372000-06-19 08:20:03 +0000627 line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000628
629# ifdef HAVE_PID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000630 ut->ut_pid = li->pid;
Damien Millerdd47aa22000-06-27 11:18:27 +1000631# endif
andre6bb92372000-06-19 08:20:03 +0000632
633 /* If we're logging out, leave all other fields blank */
634 if (li->type == LTYPE_LOGOUT)
635 return;
636
Damien Millerdd47aa22000-06-27 11:18:27 +1000637 /*
638 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000639 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000640 */
andre6bb92372000-06-19 08:20:03 +0000641
642 /* Use strncpy because we don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000643 strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000644# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000645 strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000646# endif
647# ifdef HAVE_ADDR_IN_UTMP
andre61e67252000-06-04 17:07:49 +0000648 /* this is just a 32-bit IP address */
649 if (li->hostaddr.sa.sa_family == AF_INET)
650 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000651# endif
andre61e67252000-06-04 17:07:49 +0000652}
Damien Millerdd47aa22000-06-27 11:18:27 +1000653#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
andre61e67252000-06-04 17:07:49 +0000654
andre2ff7b5d2000-06-03 14:57:40 +0000655/**
656 ** utmpx utility functions
andre61e67252000-06-04 17:07:49 +0000657 **
658 ** These functions manipulate struct utmpx, accounting for system
659 ** variations.
andre2ff7b5d2000-06-03 14:57:40 +0000660 **/
661
662#if defined(USE_UTMPX) || defined (USE_WTMPX)
andre2ff7b5d2000-06-03 14:57:40 +0000663/* build the utmpx structure */
664void
andre61e67252000-06-04 17:07:49 +0000665set_utmpx_time(struct logininfo *li, struct utmpx *utx)
666{
Damien Millerdd47aa22000-06-27 11:18:27 +1000667# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000668 utx->ut_tv.tv_sec = li->tv_sec;
669 utx->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000670# else /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000671# ifdef HAVE_TIME_IN_UTMPX
672 utx->ut_time = li->tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000673# endif /* HAVE_TIME_IN_UTMPX */
674# endif /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000675}
676
andre61e67252000-06-04 17:07:49 +0000677void
678construct_utmpx(struct logininfo *li, struct utmpx *utx)
679{
Damien Miller348c9b72000-08-15 10:01:22 +1000680 memset(utx, '\0', sizeof(*utx));
Damien Miller8e81ed32000-07-01 13:17:42 +1000681# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000682 line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
Damien Miller8e81ed32000-07-01 13:17:42 +1000683# endif
andre2ff7b5d2000-06-03 14:57:40 +0000684
685 /* this is done here to keep utmp constants out of loginrec.h */
686 switch (li->type) {
687 case LTYPE_LOGIN:
688 utx->ut_type = USER_PROCESS;
689 break;
690 case LTYPE_LOGOUT:
691 utx->ut_type = DEAD_PROCESS;
692 break;
693 }
andre2ff7b5d2000-06-03 14:57:40 +0000694 line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
andre2ff7b5d2000-06-03 14:57:40 +0000695 set_utmpx_time(li, utx);
andre6bb92372000-06-19 08:20:03 +0000696 utx->ut_pid = li->pid;
697
698 if (li->type == LTYPE_LOGOUT)
699 return;
700
Damien Millerdd47aa22000-06-27 11:18:27 +1000701 /*
702 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000703 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000704 */
andre6bb92372000-06-19 08:20:03 +0000705
706 /* strncpy(): Don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000707 strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000708# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000709 strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000710# endif
711# ifdef HAVE_ADDR_IN_UTMPX
Damien Millerd6f204d2000-09-23 13:57:27 +1100712 /* this is just a 32-bit IP address */
713 if (li->hostaddr.sa.sa_family == AF_INET)
714 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Damien Millerdd47aa22000-06-27 11:18:27 +1000715# endif
716# ifdef HAVE_SYSLEN_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000717 /* ut_syslen is the length of the utx_host string */
718 utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +1000719# endif
andre61e67252000-06-04 17:07:49 +0000720}
Damien Millerdd47aa22000-06-27 11:18:27 +1000721#endif /* USE_UTMPX || USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000722
723/**
andre61e67252000-06-04 17:07:49 +0000724 ** Low-level utmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000725 **/
726
727/* FIXME: (ATL) utmp_write_direct needs testing */
andre2ff7b5d2000-06-03 14:57:40 +0000728#ifdef USE_UTMP
729
andre2ff7b5d2000-06-03 14:57:40 +0000730/* if we can, use pututline() etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000731# if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
732 defined(HAVE_PUTUTLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000733# define UTMP_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000734# endif
andre2ff7b5d2000-06-03 14:57:40 +0000735
736
737/* write a utmp entry with the system's help (pututline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000738# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000739static int
andre61e67252000-06-04 17:07:49 +0000740utmp_write_library(struct logininfo *li, struct utmp *ut)
741{
andre2ff7b5d2000-06-03 14:57:40 +0000742 setutent();
743 pututline(ut);
744
Damien Millerdd47aa22000-06-27 11:18:27 +1000745# ifdef HAVE_ENDUTENT
andre2ff7b5d2000-06-03 14:57:40 +0000746 endutent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000747# endif
andre2ff7b5d2000-06-03 14:57:40 +0000748 return 1;
andre61e67252000-06-04 17:07:49 +0000749}
Damien Millerdd47aa22000-06-27 11:18:27 +1000750# else /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000751
752/* write a utmp entry direct to the file */
andre61e67252000-06-04 17:07:49 +0000753/* This is a slightly modification of code in OpenBSD's login.c */
andre2ff7b5d2000-06-03 14:57:40 +0000754static int
andre61e67252000-06-04 17:07:49 +0000755utmp_write_direct(struct logininfo *li, struct utmp *ut)
756{
andre2ff7b5d2000-06-03 14:57:40 +0000757 struct utmp old_ut;
758 register int fd;
759 int tty;
760
andre6bb92372000-06-19 08:20:03 +0000761 /* FIXME: (ATL) ttyslot() needs local implementation */
Damien Miller348c9b72000-08-15 10:01:22 +1000762
Damien Millere5192fa2000-08-29 14:30:37 +1100763#if defined(HAVE_GETTTYENT)
Damien Miller348c9b72000-08-15 10:01:22 +1000764 register struct ttyent *ty;
765
766 tty=0;
767
768 setttyent();
769 while ((struct ttyent *)0 != (ty = getttyent())) {
770 tty++;
771 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
772 break;
773 }
774 endttyent();
775
776 if((struct ttyent *)0 == ty) {
777 log("utmp_write_entry: tty not found");
778 return(1);
779 }
780#else /* FIXME */
781
andre2ff7b5d2000-06-03 14:57:40 +0000782 tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
783
Damien Millere5192fa2000-08-29 14:30:37 +1100784#endif /* HAVE_GETTTYENT */
Damien Miller348c9b72000-08-15 10:01:22 +1000785
andre2ff7b5d2000-06-03 14:57:40 +0000786 if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
787 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
788 /*
789 * Prevent luser from zero'ing out ut_host.
790 * If the new ut_line is empty but the old one is not
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000791 * and ut_line and ut_name match, preserve the old ut_line.
andre2ff7b5d2000-06-03 14:57:40 +0000792 */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000793 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
794 (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
795 (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000796 (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
andre2ff7b5d2000-06-03 14:57:40 +0000797 (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
Damien Miller53c5d462000-06-28 00:50:50 +1000798 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000799
andre2ff7b5d2000-06-03 14:57:40 +0000800 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
Damien Miller36ccb5c2000-08-09 16:34:27 +1000801 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
andre2ff7b5d2000-06-03 14:57:40 +0000802 log("utmp_write_direct: error writing %s: %s",
andre6bb92372000-06-19 08:20:03 +0000803 UTMP_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000804
andre2ff7b5d2000-06-03 14:57:40 +0000805 (void)close(fd);
806 return 1;
Damien Miller53c5d462000-06-28 00:50:50 +1000807 } else {
andre2ff7b5d2000-06-03 14:57:40 +0000808 return 0;
Damien Miller53c5d462000-06-28 00:50:50 +1000809 }
andre61e67252000-06-04 17:07:49 +0000810}
Damien Millerdd47aa22000-06-27 11:18:27 +1000811# endif /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000812
813static int
andre61e67252000-06-04 17:07:49 +0000814utmp_perform_login(struct logininfo *li)
815{
andre2ff7b5d2000-06-03 14:57:40 +0000816 struct utmp ut;
817
818 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000819# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000820 if (!utmp_write_library(li, &ut)) {
andre6bb92372000-06-19 08:20:03 +0000821 log("utmp_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000822 return 0;
823 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000824# else
andre2ff7b5d2000-06-03 14:57:40 +0000825 if (!utmp_write_direct(li, &ut)) {
826 log("utmp_perform_login: utmp_write_direct() failed");
827 return 0;
828 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000829# endif
andre2ff7b5d2000-06-03 14:57:40 +0000830 return 1;
andre61e67252000-06-04 17:07:49 +0000831}
andre2ff7b5d2000-06-03 14:57:40 +0000832
833
834static int
andre61e67252000-06-04 17:07:49 +0000835utmp_perform_logout(struct logininfo *li)
836{
andre2ff7b5d2000-06-03 14:57:40 +0000837 struct utmp ut;
838
andre6bb92372000-06-19 08:20:03 +0000839 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000840# ifdef UTMP_USE_LIBRARY
andre6bb92372000-06-19 08:20:03 +0000841 if (!utmp_write_library(li, &ut)) {
842 log("utmp_perform_logout: utmp_write_library() failed");
843 return 0;
844 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000845# else
andre6bb92372000-06-19 08:20:03 +0000846 if (!utmp_write_direct(li, &ut)) {
847 log("utmp_perform_logout: utmp_write_direct() failed");
848 return 0;
849 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000850# endif
andre2ff7b5d2000-06-03 14:57:40 +0000851 return 1;
andre61e67252000-06-04 17:07:49 +0000852}
andre2ff7b5d2000-06-03 14:57:40 +0000853
854
855int
andre61e67252000-06-04 17:07:49 +0000856utmp_write_entry(struct logininfo *li)
857{
andre2ff7b5d2000-06-03 14:57:40 +0000858 switch(li->type) {
859 case LTYPE_LOGIN:
860 return utmp_perform_login(li);
861
862 case LTYPE_LOGOUT:
863 return utmp_perform_logout(li);
864
865 default:
866 log("utmp_write_entry: invalid type field");
867 return 0;
868 }
andre61e67252000-06-04 17:07:49 +0000869}
Damien Millerdd47aa22000-06-27 11:18:27 +1000870#endif /* USE_UTMP */
andre2ff7b5d2000-06-03 14:57:40 +0000871
872
873/**
andre61e67252000-06-04 17:07:49 +0000874 ** Low-level utmpx functions
andre2ff7b5d2000-06-03 14:57:40 +0000875 **/
876
877/* not much point if we don't want utmpx entries */
878#ifdef USE_UTMPX
879
andre2ff7b5d2000-06-03 14:57:40 +0000880/* if we have the wherewithall, use pututxline etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000881# if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
882 defined(HAVE_PUTUTXLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000883# define UTMPX_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000884# endif
andre2ff7b5d2000-06-03 14:57:40 +0000885
886
887/* write a utmpx entry with the system's help (pututxline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000888# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000889static int
andre61e67252000-06-04 17:07:49 +0000890utmpx_write_library(struct logininfo *li, struct utmpx *utx)
891{
andre2ff7b5d2000-06-03 14:57:40 +0000892 setutxent();
893 pututxline(utx);
894
Damien Millerdd47aa22000-06-27 11:18:27 +1000895# ifdef HAVE_ENDUTXENT
andre2ff7b5d2000-06-03 14:57:40 +0000896 endutxent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000897# endif
andre2ff7b5d2000-06-03 14:57:40 +0000898 return 1;
andre61e67252000-06-04 17:07:49 +0000899}
andre2ff7b5d2000-06-03 14:57:40 +0000900
Damien Millerdd47aa22000-06-27 11:18:27 +1000901# else /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000902
903/* write a utmp entry direct to the file */
904static int
andre61e67252000-06-04 17:07:49 +0000905utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000906{
andre2ff7b5d2000-06-03 14:57:40 +0000907 log("utmpx_write_direct: not implemented!");
908 return 0;
andre61e67252000-06-04 17:07:49 +0000909}
Damien Millerdd47aa22000-06-27 11:18:27 +1000910# endif /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000911
912static int
andre61e67252000-06-04 17:07:49 +0000913utmpx_perform_login(struct logininfo *li)
914{
andre2ff7b5d2000-06-03 14:57:40 +0000915 struct utmpx utx;
916
917 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000918# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000919 if (!utmpx_write_library(li, &utx)) {
920 log("utmpx_perform_login: utmp_write_library() failed");
921 return 0;
922 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000923# else
andre2ff7b5d2000-06-03 14:57:40 +0000924 if (!utmpx_write_direct(li, &ut)) {
925 log("utmpx_perform_login: utmp_write_direct() failed");
926 return 0;
927 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000928# endif
andre2ff7b5d2000-06-03 14:57:40 +0000929 return 1;
andre61e67252000-06-04 17:07:49 +0000930}
andre2ff7b5d2000-06-03 14:57:40 +0000931
932
933static int
andre61e67252000-06-04 17:07:49 +0000934utmpx_perform_logout(struct logininfo *li)
935{
andre2ff7b5d2000-06-03 14:57:40 +0000936 struct utmpx utx;
937
938 memset(&utx, '\0', sizeof(utx));
939 set_utmpx_time(li, &utx);
940 line_stripname(utx.ut_line, li->line, sizeof(utx.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000941# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000942 line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000943# endif
944# ifdef HAVE_TYPE_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000945 utx.ut_type = DEAD_PROCESS;
Damien Millerdd47aa22000-06-27 11:18:27 +1000946# endif
andre2ff7b5d2000-06-03 14:57:40 +0000947
Damien Millerdd47aa22000-06-27 11:18:27 +1000948# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000949 utmpx_write_library(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000950# else
andre2ff7b5d2000-06-03 14:57:40 +0000951 utmpx_write_direct(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000952# endif
andre2ff7b5d2000-06-03 14:57:40 +0000953 return 1;
andre61e67252000-06-04 17:07:49 +0000954}
andre2ff7b5d2000-06-03 14:57:40 +0000955
andre2ff7b5d2000-06-03 14:57:40 +0000956int
andre61e67252000-06-04 17:07:49 +0000957utmpx_write_entry(struct logininfo *li)
958{
andre2ff7b5d2000-06-03 14:57:40 +0000959 switch(li->type) {
960 case LTYPE_LOGIN:
961 return utmpx_perform_login(li);
962 case LTYPE_LOGOUT:
963 return utmpx_perform_logout(li);
964 default:
965 log("utmpx_write_entry: invalid type field");
966 return 0;
967 }
andre61e67252000-06-04 17:07:49 +0000968}
Damien Millerdd47aa22000-06-27 11:18:27 +1000969#endif /* USE_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000970
971
972/**
andre61e67252000-06-04 17:07:49 +0000973 ** Low-level wtmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000974 **/
975
Kevin Stevesef4eea92001-02-05 12:42:17 +0000976#ifdef USE_WTMP
andre2ff7b5d2000-06-03 14:57:40 +0000977
andre2ff7b5d2000-06-03 14:57:40 +0000978/* write a wtmp entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +0000979/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +0000980static int
andre61e67252000-06-04 17:07:49 +0000981wtmp_write(struct logininfo *li, struct utmp *ut)
982{
andre2ff7b5d2000-06-03 14:57:40 +0000983 struct stat buf;
984 int fd, ret = 1;
985
986 if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
987 log("wtmp_write: problem writing %s: %s",
988 WTMP_FILE, strerror(errno));
989 return 0;
990 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000991 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +1000992 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
andre2ff7b5d2000-06-03 14:57:40 +0000993 ftruncate(fd, buf.st_size);
994 log("wtmp_write: problem writing %s: %s",
995 WTMP_FILE, strerror(errno));
996 ret = 0;
997 }
998 (void)close(fd);
andre2ff7b5d2000-06-03 14:57:40 +0000999 return ret;
andre61e67252000-06-04 17:07:49 +00001000}
andre2ff7b5d2000-06-03 14:57:40 +00001001
andre2ff7b5d2000-06-03 14:57:40 +00001002static int
Damien Millerdd47aa22000-06-27 11:18:27 +10001003wtmp_perform_login(struct logininfo *li)
1004{
andre2ff7b5d2000-06-03 14:57:40 +00001005 struct utmp ut;
1006
1007 construct_utmp(li, &ut);
1008 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001009}
andre2ff7b5d2000-06-03 14:57:40 +00001010
1011
1012static int
andre61e67252000-06-04 17:07:49 +00001013wtmp_perform_logout(struct logininfo *li)
1014{
andre2ff7b5d2000-06-03 14:57:40 +00001015 struct utmp ut;
1016
1017 construct_utmp(li, &ut);
andre2ff7b5d2000-06-03 14:57:40 +00001018 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +00001019}
andre2ff7b5d2000-06-03 14:57:40 +00001020
1021
1022int
andre61e67252000-06-04 17:07:49 +00001023wtmp_write_entry(struct logininfo *li)
1024{
andre2ff7b5d2000-06-03 14:57:40 +00001025 switch(li->type) {
1026 case LTYPE_LOGIN:
1027 return wtmp_perform_login(li);
1028 case LTYPE_LOGOUT:
1029 return wtmp_perform_logout(li);
1030 default:
1031 log("wtmp_write_entry: invalid type field");
1032 return 0;
1033 }
andre61e67252000-06-04 17:07:49 +00001034}
andre2ff7b5d2000-06-03 14:57:40 +00001035
1036
andre6bb92372000-06-19 08:20:03 +00001037/* Notes on fetching login data from wtmp/wtmpx
Kevin Stevesef4eea92001-02-05 12:42:17 +00001038 *
andre6bb92372000-06-19 08:20:03 +00001039 * Logouts are usually recorded with (amongst other things) a blank
1040 * username on a given tty line. However, some systems (HP-UX is one)
1041 * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1042 *
1043 * Since we're only looking for logins here, we know that the username
1044 * must be set correctly. On systems that leave it in, we check for
1045 * ut_type==USER_PROCESS (indicating a login.)
1046 *
1047 * Portability: Some systems may set something other than USER_PROCESS
1048 * to indicate a login process. I don't know of any as I write. Also,
1049 * it's possible that some systems may both leave the username in
1050 * place and not have ut_type.
1051 */
1052
andre6bb92372000-06-19 08:20:03 +00001053/* return true if this wtmp entry indicates a login */
1054static int
1055wtmp_islogin(struct logininfo *li, struct utmp *ut)
1056{
Kevin Stevesef4eea92001-02-05 12:42:17 +00001057 if (strncmp(li->username, ut->ut_name,
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001058 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001059# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001060 if (ut->ut_type & USER_PROCESS)
1061 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001062# else
andre6bb92372000-06-19 08:20:03 +00001063 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001064# endif
andre6bb92372000-06-19 08:20:03 +00001065 }
1066 return 0;
1067}
1068
andre2ff7b5d2000-06-03 14:57:40 +00001069int
andre61e67252000-06-04 17:07:49 +00001070wtmp_get_entry(struct logininfo *li)
1071{
andre2ff7b5d2000-06-03 14:57:40 +00001072 struct stat st;
1073 struct utmp ut;
andre6bb92372000-06-19 08:20:03 +00001074 int fd, found=0;
1075
1076 /* Clear the time entries in our logininfo */
1077 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001078
1079 if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1080 log("wtmp_get_entry: problem opening %s: %s",
1081 WTMP_FILE, strerror(errno));
1082 return 0;
1083 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001084 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001085 log("wtmp_get_entry: couldn't stat %s: %s",
1086 WTMP_FILE, strerror(errno));
1087 close(fd);
1088 return 0;
1089 }
andre2ff7b5d2000-06-03 14:57:40 +00001090
andre6bb92372000-06-19 08:20:03 +00001091 /* Seek to the start of the last struct utmp */
Damien Miller348c9b72000-08-15 10:01:22 +10001092 if (lseek(fd, (off_t)(0 - sizeof(struct utmp)), SEEK_END) == -1) {
andre6bb92372000-06-19 08:20:03 +00001093 /* Looks like we've got a fresh wtmp file */
1094 close(fd);
1095 return 0;
1096 }
1097
1098 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001099 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001100 log("wtmp_get_entry: read of %s failed: %s",
1101 WTMP_FILE, strerror(errno));
1102 close (fd);
1103 return 0;
1104 }
andre6bb92372000-06-19 08:20:03 +00001105 if ( wtmp_islogin(li, &ut) ) {
1106 found = 1;
1107 /* We've already checked for a time in struct
1108 * utmp, in login_getlast(). */
Damien Millerdd47aa22000-06-27 11:18:27 +10001109# ifdef HAVE_TIME_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +00001110 li->tv_sec = ut.ut_time;
Damien Millerdd47aa22000-06-27 11:18:27 +10001111# else
andre2ff7b5d2000-06-03 14:57:40 +00001112# if HAVE_TV_IN_UTMP
1113 li->tv_sec = ut.ut_tv.tv_sec;
1114# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001115# endif
andre6bb92372000-06-19 08:20:03 +00001116 line_fullname(li->line, ut.ut_line,
1117 MIN_SIZEOF(li->line, ut.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001118# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001119 strlcpy(li->hostname, ut.ut_host,
1120 MIN_SIZEOF(li->hostname, ut.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001121# endif
andre6bb92372000-06-19 08:20:03 +00001122 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001123 }
andre6bb92372000-06-19 08:20:03 +00001124 /* Seek back 2 x struct utmp */
andre2ff7b5d2000-06-03 14:57:40 +00001125 if (lseek(fd, (off_t)(0-2*sizeof(struct utmp)), SEEK_CUR) == -1) {
andre6bb92372000-06-19 08:20:03 +00001126 /* We've found the start of the file, so quit */
andre2ff7b5d2000-06-03 14:57:40 +00001127 close (fd);
1128 return 0;
1129 }
andre6bb92372000-06-19 08:20:03 +00001130 }
1131
1132 /* We found an entry. Tidy up and return */
1133 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001134 return 1;
andre61e67252000-06-04 17:07:49 +00001135}
Damien Millerdd47aa22000-06-27 11:18:27 +10001136# endif /* USE_WTMP */
andre2ff7b5d2000-06-03 14:57:40 +00001137
1138
1139/**
andre61e67252000-06-04 17:07:49 +00001140 ** Low-level wtmpx functions
andre2ff7b5d2000-06-03 14:57:40 +00001141 **/
1142
1143#ifdef USE_WTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001144/* write a wtmpx entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001145/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001146static int
andre61e67252000-06-04 17:07:49 +00001147wtmpx_write(struct logininfo *li, struct utmpx *utx)
1148{
andre2ff7b5d2000-06-03 14:57:40 +00001149 struct stat buf;
1150 int fd, ret = 1;
1151
1152 if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1153 log("wtmpx_write: problem opening %s: %s",
1154 WTMPX_FILE, strerror(errno));
1155 return 0;
1156 }
1157
Kevin Stevesef4eea92001-02-05 12:42:17 +00001158 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001159 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001160 ftruncate(fd, buf.st_size);
1161 log("wtmpx_write: problem writing %s: %s",
1162 WTMPX_FILE, strerror(errno));
1163 ret = 0;
1164 }
1165 (void)close(fd);
1166
1167 return ret;
andre61e67252000-06-04 17:07:49 +00001168}
andre2ff7b5d2000-06-03 14:57:40 +00001169
1170
1171static int
andre61e67252000-06-04 17:07:49 +00001172wtmpx_perform_login(struct logininfo *li)
1173{
andre2ff7b5d2000-06-03 14:57:40 +00001174 struct utmpx utx;
1175
1176 construct_utmpx(li, &utx);
1177 return wtmpx_write(li, &utx);
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_logout(struct logininfo *li)
1183{
andre2ff7b5d2000-06-03 14:57:40 +00001184 struct utmpx utx;
1185
1186 construct_utmpx(li, &utx);
andre2ff7b5d2000-06-03 14:57:40 +00001187 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001188}
andre2ff7b5d2000-06-03 14:57:40 +00001189
1190
1191int
andre61e67252000-06-04 17:07:49 +00001192wtmpx_write_entry(struct logininfo *li)
1193{
andre2ff7b5d2000-06-03 14:57:40 +00001194 switch(li->type) {
1195 case LTYPE_LOGIN:
1196 return wtmpx_perform_login(li);
1197 case LTYPE_LOGOUT:
1198 return wtmpx_perform_logout(li);
1199 default:
1200 log("wtmpx_write_entry: invalid type field");
1201 return 0;
1202 }
andre61e67252000-06-04 17:07:49 +00001203}
andre2ff7b5d2000-06-03 14:57:40 +00001204
andre6bb92372000-06-19 08:20:03 +00001205/* Please see the notes above wtmp_islogin() for information about the
1206 next two functions */
1207
1208/* Return true if this wtmpx entry indicates a login */
1209static int
1210wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1211{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001212 if ( strncmp(li->username, utx->ut_name,
1213 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001214# ifdef HAVE_TYPE_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001215 if (utx->ut_type == USER_PROCESS)
1216 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001217# else
andre6bb92372000-06-19 08:20:03 +00001218 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001219# endif
andre6bb92372000-06-19 08:20:03 +00001220 }
1221 return 0;
1222}
1223
andre2ff7b5d2000-06-03 14:57:40 +00001224
1225int
andre61e67252000-06-04 17:07:49 +00001226wtmpx_get_entry(struct logininfo *li)
1227{
andre2ff7b5d2000-06-03 14:57:40 +00001228 struct stat st;
1229 struct utmpx utx;
andre6bb92372000-06-19 08:20:03 +00001230 int fd, found=0;
1231
1232 /* Clear the time entries */
1233 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001234
1235 if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1236 log("wtmpx_get_entry: problem opening %s: %s",
1237 WTMPX_FILE, strerror(errno));
1238 return 0;
1239 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001240 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001241 log("wtmpx_get_entry: couldn't stat %s: %s",
1242 WTMP_FILE, strerror(errno));
1243 close(fd);
1244 return 0;
1245 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001246
andre6bb92372000-06-19 08:20:03 +00001247 /* Seek to the start of the last struct utmpx */
1248 if (lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END) == -1 ) {
1249 /* probably a newly rotated wtmpx file */
1250 close(fd);
1251 return 0;
1252 }
andre2ff7b5d2000-06-03 14:57:40 +00001253
andre6bb92372000-06-19 08:20:03 +00001254 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001255 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001256 log("wtmpx_get_entry: read of %s failed: %s",
1257 WTMPX_FILE, strerror(errno));
1258 close (fd);
1259 return 0;
1260 }
andre2ff7b5d2000-06-03 14:57:40 +00001261 /* Logouts are recorded as a blank username on a particular line.
1262 * So, we just need to find the username in struct utmpx */
andre6bb92372000-06-19 08:20:03 +00001263 if ( wtmpx_islogin(li, &utx) ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001264# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001265 li->tv_sec = utx.ut_tv.tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +10001266# else
andre2ff7b5d2000-06-03 14:57:40 +00001267# ifdef HAVE_TIME_IN_UTMPX
1268 li->tv_sec = utx.ut_time;
1269# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001270# endif
Damien Miller1a132252000-06-13 21:23:17 +10001271 line_fullname(li->line, utx.ut_line, sizeof(li->line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001272# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001273 strlcpy(li->hostname, utx.ut_host,
1274 MIN_SIZEOF(li->hostname, utx.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001275# endif
andre6bb92372000-06-19 08:20:03 +00001276 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001277 }
1278 if (lseek(fd, (off_t)(0-2*sizeof(struct utmpx)), SEEK_CUR) == -1) {
1279 close (fd);
1280 return 0;
1281 }
andre6bb92372000-06-19 08:20:03 +00001282 }
1283
1284 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001285 return 1;
andre61e67252000-06-04 17:07:49 +00001286}
Damien Millerd5bf3072000-06-07 21:32:13 +10001287#endif /* USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001288
andre2ff7b5d2000-06-03 14:57:40 +00001289/**
andre61e67252000-06-04 17:07:49 +00001290 ** Low-level libutil login() functions
andre2ff7b5d2000-06-03 14:57:40 +00001291 **/
1292
1293#ifdef USE_LOGIN
andre2ff7b5d2000-06-03 14:57:40 +00001294static int
andre61e67252000-06-04 17:07:49 +00001295syslogin_perform_login(struct logininfo *li)
1296{
andre2ff7b5d2000-06-03 14:57:40 +00001297 struct utmp *ut;
1298
Damien Miller348c9b72000-08-15 10:01:22 +10001299 if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
andre2ff7b5d2000-06-03 14:57:40 +00001300 log("syslogin_perform_login: couldn't malloc()");
1301 return 0;
1302 }
1303 construct_utmp(li, ut);
1304 login(ut);
1305
1306 return 1;
andre61e67252000-06-04 17:07:49 +00001307}
1308
andre2ff7b5d2000-06-03 14:57:40 +00001309static int
andre61e67252000-06-04 17:07:49 +00001310syslogin_perform_logout(struct logininfo *li)
1311{
Damien Millerdd47aa22000-06-27 11:18:27 +10001312# ifdef HAVE_LOGOUT
andre2ff7b5d2000-06-03 14:57:40 +00001313 char line[8];
Kevin Stevesef4eea92001-02-05 12:42:17 +00001314
andre2ff7b5d2000-06-03 14:57:40 +00001315 (void)line_stripname(line, li->line, sizeof(line));
1316
1317 if (!logout(line)) {
1318 log("syslogin_perform_logout: logout() returned an error");
Damien Millerdd47aa22000-06-27 11:18:27 +10001319# ifdef HAVE_LOGWTMP
andre2ff7b5d2000-06-03 14:57:40 +00001320 } else {
1321 logwtmp(line, "", "");
Damien Millerdd47aa22000-06-27 11:18:27 +10001322# endif
Damien Miller9b6d4ab2000-07-02 08:43:18 +10001323 }
andre6bb92372000-06-19 08:20:03 +00001324 /* FIXME: (ATL - if the need arises) What to do if we have
1325 * login, but no logout? what if logout but no logwtmp? All
1326 * routines are in libutil so they should all be there,
1327 * but... */
Damien Millerdd47aa22000-06-27 11:18:27 +10001328# endif
andre2ff7b5d2000-06-03 14:57:40 +00001329 return 1;
andre61e67252000-06-04 17:07:49 +00001330}
andre2ff7b5d2000-06-03 14:57:40 +00001331
andre2ff7b5d2000-06-03 14:57:40 +00001332int
andre61e67252000-06-04 17:07:49 +00001333syslogin_write_entry(struct logininfo *li)
1334{
andre2ff7b5d2000-06-03 14:57:40 +00001335 switch (li->type) {
1336 case LTYPE_LOGIN:
1337 return syslogin_perform_login(li);
1338 case LTYPE_LOGOUT:
1339 return syslogin_perform_logout(li);
1340 default:
1341 log("syslogin_write_entry: Invalid type field");
1342 return 0;
1343 }
andre61e67252000-06-04 17:07:49 +00001344}
Damien Millerd5bf3072000-06-07 21:32:13 +10001345#endif /* USE_LOGIN */
andre2ff7b5d2000-06-03 14:57:40 +00001346
1347/* end of file log-syslogin.c */
1348
andre2ff7b5d2000-06-03 14:57:40 +00001349/**
andre61e67252000-06-04 17:07:49 +00001350 ** Low-level lastlog functions
andre2ff7b5d2000-06-03 14:57:40 +00001351 **/
1352
1353#ifdef USE_LASTLOG
Damien Millerdd47aa22000-06-27 11:18:27 +10001354#define LL_FILE 1
1355#define LL_DIR 2
1356#define LL_OTHER 3
andre2ff7b5d2000-06-03 14:57:40 +00001357
andre2ff7b5d2000-06-03 14:57:40 +00001358static void
andre61e67252000-06-04 17:07:49 +00001359lastlog_construct(struct logininfo *li, struct lastlog *last)
1360{
andre2ff7b5d2000-06-03 14:57:40 +00001361 /* clear the structure */
Damien Miller348c9b72000-08-15 10:01:22 +10001362 memset(last, '\0', sizeof(*last));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001363
Damien Millerdd47aa22000-06-27 11:18:27 +10001364 (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
andre6bb92372000-06-19 08:20:03 +00001365 strlcpy(last->ll_host, li->hostname,
1366 MIN_SIZEOF(last->ll_host, li->hostname));
andre2ff7b5d2000-06-03 14:57:40 +00001367 last->ll_time = li->tv_sec;
andre61e67252000-06-04 17:07:49 +00001368}
andre2ff7b5d2000-06-03 14:57:40 +00001369
andre2ff7b5d2000-06-03 14:57:40 +00001370static int
andre61e67252000-06-04 17:07:49 +00001371lastlog_filetype(char *filename)
1372{
andre2ff7b5d2000-06-03 14:57:40 +00001373 struct stat st;
1374
Damien Millerdd47aa22000-06-27 11:18:27 +10001375 if (stat(LASTLOG_FILE, &st) != 0) {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001376 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
Damien Millerdd47aa22000-06-27 11:18:27 +10001377 strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001378 return 0;
1379 }
andre2ff7b5d2000-06-03 14:57:40 +00001380 if (S_ISDIR(st.st_mode))
1381 return LL_DIR;
1382 else if (S_ISREG(st.st_mode))
1383 return LL_FILE;
1384 else
1385 return LL_OTHER;
andre61e67252000-06-04 17:07:49 +00001386}
andre2ff7b5d2000-06-03 14:57:40 +00001387
1388
1389/* open the file (using filemode) and seek to the login entry */
1390static int
andre61e67252000-06-04 17:07:49 +00001391lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1392{
andre2ff7b5d2000-06-03 14:57:40 +00001393 off_t offset;
1394 int type;
1395 char lastlog_file[1024];
1396
1397 type = lastlog_filetype(LASTLOG_FILE);
1398 switch (type) {
Damien Millerf8af08d2000-06-27 09:40:06 +10001399 case LL_FILE:
1400 strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1401 break;
1402 case LL_DIR:
1403 snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1404 LASTLOG_FILE, li->username);
1405 break;
1406 default:
1407 log("lastlog_openseek: %.100s is not a file or directory!",
1408 LASTLOG_FILE);
1409 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001410 }
andre2ff7b5d2000-06-03 14:57:40 +00001411
1412 *fd = open(lastlog_file, filemode);
1413 if ( *fd < 0) {
Damien Miller53c5d462000-06-28 00:50:50 +10001414 debug("lastlog_openseek: Couldn't open %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001415 lastlog_file, strerror(errno));
1416 return 0;
1417 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001418
Damien Millere477ef62000-08-15 10:21:17 +10001419 if (type == LL_FILE) {
1420 /* find this uid's offset in the lastlog file */
1421 offset = (off_t) ( (long)li->uid * sizeof(struct lastlog));
andre2ff7b5d2000-06-03 14:57:40 +00001422
Damien Millere477ef62000-08-15 10:21:17 +10001423 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1424 log("lastlog_openseek: %s->lseek(): %s",
Kevin Stevesef4eea92001-02-05 12:42:17 +00001425 lastlog_file, strerror(errno));
Damien Millere477ef62000-08-15 10:21:17 +10001426 return 0;
1427 }
andre2ff7b5d2000-06-03 14:57:40 +00001428 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001429
andre2ff7b5d2000-06-03 14:57:40 +00001430 return 1;
andre61e67252000-06-04 17:07:49 +00001431}
andre2ff7b5d2000-06-03 14:57:40 +00001432
1433static int
andre61e67252000-06-04 17:07:49 +00001434lastlog_perform_login(struct logininfo *li)
1435{
andre2ff7b5d2000-06-03 14:57:40 +00001436 struct lastlog last;
1437 int fd;
1438
1439 /* create our struct lastlog */
1440 lastlog_construct(li, &last);
1441
Damien Millerc1132e72000-08-18 14:08:38 +10001442 if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1443 return(0);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001444
andre2ff7b5d2000-06-03 14:57:40 +00001445 /* write the entry */
Damien Millerc1132e72000-08-18 14:08:38 +10001446 if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1447 close(fd);
1448 log("lastlog_write_filemode: Error writing to %s: %s",
1449 LASTLOG_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001450 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001451 }
Damien Millerc1132e72000-08-18 14:08:38 +10001452
1453 close(fd);
1454 return 1;
andre61e67252000-06-04 17:07:49 +00001455}
andre2ff7b5d2000-06-03 14:57:40 +00001456
andre2ff7b5d2000-06-03 14:57:40 +00001457int
andre61e67252000-06-04 17:07:49 +00001458lastlog_write_entry(struct logininfo *li)
1459{
andre2ff7b5d2000-06-03 14:57:40 +00001460 switch(li->type) {
1461 case LTYPE_LOGIN:
1462 return lastlog_perform_login(li);
1463 default:
1464 log("lastlog_write_entry: Invalid type field");
1465 return 0;
1466 }
andre61e67252000-06-04 17:07:49 +00001467}
andre2ff7b5d2000-06-03 14:57:40 +00001468
andre2ff7b5d2000-06-03 14:57:40 +00001469static void
andre61e67252000-06-04 17:07:49 +00001470lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1471{
andre2ff7b5d2000-06-03 14:57:40 +00001472 line_fullname(li->line, last->ll_line, sizeof(li->line));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001473 strlcpy(li->hostname, last->ll_host,
andre6bb92372000-06-19 08:20:03 +00001474 MIN_SIZEOF(li->hostname, last->ll_host));
andre2ff7b5d2000-06-03 14:57:40 +00001475 li->tv_sec = last->ll_time;
andre61e67252000-06-04 17:07:49 +00001476}
andre2ff7b5d2000-06-03 14:57:40 +00001477
andre2ff7b5d2000-06-03 14:57:40 +00001478int
andre61e67252000-06-04 17:07:49 +00001479lastlog_get_entry(struct logininfo *li)
1480{
andre2ff7b5d2000-06-03 14:57:40 +00001481 struct lastlog last;
1482 int fd;
1483
1484 if (lastlog_openseek(li, &fd, O_RDONLY)) {
Damien Miller53c5d462000-06-28 00:50:50 +10001485 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1486 log("lastlog_get_entry: Error reading from %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001487 LASTLOG_FILE, strerror(errno));
1488 return 0;
1489 } else {
1490 lastlog_populate_entry(li, &last);
1491 return 1;
1492 }
Damien Millerdd47aa22000-06-27 11:18:27 +10001493 } else {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001494 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001495 }
andre61e67252000-06-04 17:07:49 +00001496}
Damien Millerd5bf3072000-06-07 21:32:13 +10001497#endif /* USE_LASTLOG */