blob: c703663aee469d9ed0e68834144909f6b1de6282 [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
Kevin Steves77aeaaf2001-02-22 21:23:21 +0000166RCSID("$Id: loginrec.c,v 1.32 2001/02/22 21:23:21 stevesk 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
andre2ff7b5d2000-06-03 14:57:40 +0000446/**
andre61e67252000-06-04 17:07:49 +0000447 ** getlast_entry: Call low-level functions to retrieve the last login
448 ** time.
andre2ff7b5d2000-06-03 14:57:40 +0000449 **/
450
andre61e67252000-06-04 17:07:49 +0000451/* take the uid in li and return the last login time */
452int
453getlast_entry(struct logininfo *li)
454{
455#ifdef USE_LASTLOG
Damien Miller53c5d462000-06-28 00:50:50 +1000456 return(lastlog_get_entry(li));
Damien Millerdd47aa22000-06-27 11:18:27 +1000457#else /* !USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000458
Damien Millerdd47aa22000-06-27 11:18:27 +1000459#ifdef DISABLE_LASTLOG
Kevin Stevesef4eea92001-02-05 12:42:17 +0000460 /* On some systems we shouldn't even try to obtain last login
andreecaabf12000-06-12 22:21:44 +0000461 * time, e.g. AIX */
462 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000463# else /* DISABLE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000464 /* Try to retrieve the last login time from wtmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000465# if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
andre61e67252000-06-04 17:07:49 +0000466 /* retrieve last login time from utmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000467 return (wtmp_get_entry(li));
468# else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
andre61e67252000-06-04 17:07:49 +0000469 /* If wtmp isn't available, try wtmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000470# if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
andre61e67252000-06-04 17:07:49 +0000471 /* retrieve last login time from utmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000472 return (wtmpx_get_entry(li));
473# else
andre61e67252000-06-04 17:07:49 +0000474 /* Give up: No means of retrieving last login time */
475 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000476# endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
477# endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000478# endif /* DISABLE_LASTLOG */
Damien Millerdd47aa22000-06-27 11:18:27 +1000479#endif /* USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000480}
481
482
483
andre2ff7b5d2000-06-03 14:57:40 +0000484/*
andre61e67252000-06-04 17:07:49 +0000485 * 'line' string utility functions
486 *
487 * These functions process the 'line' string into one of three forms:
488 *
andre2ff7b5d2000-06-03 14:57:40 +0000489 * 1. The full filename (including '/dev')
490 * 2. The stripped name (excluding '/dev')
andre61e67252000-06-04 17:07:49 +0000491 * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
492 * /dev/pts/1 -> ts/1 )
andre2ff7b5d2000-06-03 14:57:40 +0000493 *
494 * Form 3 is used on some systems to identify a .tmp.? entry when
495 * attempting to remove it. Typically both addition and removal is
andre61e67252000-06-04 17:07:49 +0000496 * performed by one application - say, sshd - so as long as the choice
497 * uniquely identifies a terminal it's ok.
andre2ff7b5d2000-06-03 14:57:40 +0000498 */
499
500
andre61e67252000-06-04 17:07:49 +0000501/* line_fullname(): add the leading '/dev/' if it doesn't exist make
502 * sure dst has enough space, if not just copy src (ugh) */
andre2ff7b5d2000-06-03 14:57:40 +0000503char *
andre61e67252000-06-04 17:07:49 +0000504line_fullname(char *dst, const char *src, int dstsize)
505{
andre2ff7b5d2000-06-03 14:57:40 +0000506 memset(dst, '\0', dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100507 if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
andre2ff7b5d2000-06-03 14:57:40 +0000508 strlcpy(dst, src, dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100509 } else {
Damien Miller1a132252000-06-13 21:23:17 +1000510 strlcpy(dst, "/dev/", dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000511 strlcat(dst, src, dstsize);
512 }
513 return dst;
514}
515
andre61e67252000-06-04 17:07:49 +0000516/* line_stripname(): strip the leading '/dev' if it exists, return dst */
andre2ff7b5d2000-06-03 14:57:40 +0000517char *
andre61e67252000-06-04 17:07:49 +0000518line_stripname(char *dst, const char *src, int dstsize)
519{
andre2ff7b5d2000-06-03 14:57:40 +0000520 memset(dst, '\0', dstsize);
521 if (strncmp(src, "/dev/", 5) == 0)
Damien Millerf5a81472000-09-30 21:34:44 +1100522 strlcpy(dst, src + 5, dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000523 else
524 strlcpy(dst, src, dstsize);
525 return dst;
andre61e67252000-06-04 17:07:49 +0000526}
527
andre61e67252000-06-04 17:07:49 +0000528/* line_abbrevname(): Return the abbreviated (usually four-character)
529 * form of the line (Just use the last <dstsize> characters of the
530 * full name.)
531 *
532 * NOTE: use strncpy because we do NOT necessarily want zero
533 * termination */
andre2ff7b5d2000-06-03 14:57:40 +0000534char *
Kevin Stevesef4eea92001-02-05 12:42:17 +0000535line_abbrevname(char *dst, const char *src, int dstsize)
Damien Millerdd47aa22000-06-27 11:18:27 +1000536{
537 size_t len;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000538
andre2ff7b5d2000-06-03 14:57:40 +0000539 memset(dst, '\0', dstsize);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000540
Damien Miller8e81ed32000-07-01 13:17:42 +1000541 /* Always skip prefix if present */
542 if (strncmp(src, "/dev/", 5) == 0)
543 src += 5;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000544
Damien Millerdd47aa22000-06-27 11:18:27 +1000545 len = strlen(src);
546
Damien Miller8e81ed32000-07-01 13:17:42 +1000547 if (len > 0) {
548 if (((int)len - dstsize) > 0)
549 src += ((int)len - dstsize);
550
551 /* note: _don't_ change this to strlcpy */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000552 strncpy(dst, src, (size_t)dstsize);
Damien Millerdd47aa22000-06-27 11:18:27 +1000553 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000554
andre2ff7b5d2000-06-03 14:57:40 +0000555 return dst;
556}
557
andre2ff7b5d2000-06-03 14:57:40 +0000558/**
559 ** utmp utility functions
andre61e67252000-06-04 17:07:49 +0000560 **
561 ** These functions manipulate struct utmp, taking system differences
562 ** into account.
andre2ff7b5d2000-06-03 14:57:40 +0000563 **/
564
565#if defined(USE_UTMP) || defined (USE_WTMP) || defined (USE_LOGIN)
566
andre2ff7b5d2000-06-03 14:57:40 +0000567/* build the utmp structure */
568void
andre61e67252000-06-04 17:07:49 +0000569set_utmp_time(struct logininfo *li, struct utmp *ut)
570{
Damien Millerdd47aa22000-06-27 11:18:27 +1000571# ifdef HAVE_TV_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000572 ut->ut_tv.tv_sec = li->tv_sec;
573 ut->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000574# else
andre2ff7b5d2000-06-03 14:57:40 +0000575# ifdef HAVE_TIME_IN_UTMP
576 ut->ut_time = li->tv_sec;
577# endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000578# endif
andre2ff7b5d2000-06-03 14:57:40 +0000579}
580
581void
582construct_utmp(struct logininfo *li,
andre61e67252000-06-04 17:07:49 +0000583 struct utmp *ut)
584{
Damien Miller348c9b72000-08-15 10:01:22 +1000585 memset(ut, '\0', sizeof(*ut));
andre6bb92372000-06-19 08:20:03 +0000586
587 /* First fill out fields used for both logins and logouts */
588
Damien Millerdd47aa22000-06-27 11:18:27 +1000589# ifdef HAVE_ID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000590 line_abbrevname(ut->ut_id, li->line, sizeof(ut->ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000591# endif
andre2ff7b5d2000-06-03 14:57:40 +0000592
Damien Millerdd47aa22000-06-27 11:18:27 +1000593# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000594 /* This is done here to keep utmp constants out of struct logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000595 switch (li->type) {
596 case LTYPE_LOGIN:
597 ut->ut_type = USER_PROCESS;
598 break;
599 case LTYPE_LOGOUT:
600 ut->ut_type = DEAD_PROCESS;
601 break;
602 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000603# endif
andre6bb92372000-06-19 08:20:03 +0000604 set_utmp_time(li, ut);
andre2ff7b5d2000-06-03 14:57:40 +0000605
andre6bb92372000-06-19 08:20:03 +0000606 line_stripname(ut->ut_line, li->line, sizeof(ut->ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000607
608# ifdef HAVE_PID_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +0000609 ut->ut_pid = li->pid;
Damien Millerdd47aa22000-06-27 11:18:27 +1000610# endif
andre6bb92372000-06-19 08:20:03 +0000611
612 /* If we're logging out, leave all other fields blank */
613 if (li->type == LTYPE_LOGOUT)
614 return;
615
Damien Millerdd47aa22000-06-27 11:18:27 +1000616 /*
617 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000618 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000619 */
andre6bb92372000-06-19 08:20:03 +0000620
621 /* Use strncpy because we don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000622 strncpy(ut->ut_name, li->username, MIN_SIZEOF(ut->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000623# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +0000624 strncpy(ut->ut_host, li->hostname, MIN_SIZEOF(ut->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000625# endif
626# ifdef HAVE_ADDR_IN_UTMP
andre61e67252000-06-04 17:07:49 +0000627 /* this is just a 32-bit IP address */
628 if (li->hostaddr.sa.sa_family == AF_INET)
629 ut->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000630# endif
andre61e67252000-06-04 17:07:49 +0000631}
Damien Millerdd47aa22000-06-27 11:18:27 +1000632#endif /* USE_UTMP || USE_WTMP || USE_LOGIN */
andre61e67252000-06-04 17:07:49 +0000633
andre2ff7b5d2000-06-03 14:57:40 +0000634/**
635 ** utmpx utility functions
andre61e67252000-06-04 17:07:49 +0000636 **
637 ** These functions manipulate struct utmpx, accounting for system
638 ** variations.
andre2ff7b5d2000-06-03 14:57:40 +0000639 **/
640
641#if defined(USE_UTMPX) || defined (USE_WTMPX)
andre2ff7b5d2000-06-03 14:57:40 +0000642/* build the utmpx structure */
643void
andre61e67252000-06-04 17:07:49 +0000644set_utmpx_time(struct logininfo *li, struct utmpx *utx)
645{
Damien Millerdd47aa22000-06-27 11:18:27 +1000646# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000647 utx->ut_tv.tv_sec = li->tv_sec;
648 utx->ut_tv.tv_usec = li->tv_usec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000649# else /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000650# ifdef HAVE_TIME_IN_UTMPX
651 utx->ut_time = li->tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +1000652# endif /* HAVE_TIME_IN_UTMPX */
653# endif /* HAVE_TV_IN_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000654}
655
andre61e67252000-06-04 17:07:49 +0000656void
657construct_utmpx(struct logininfo *li, struct utmpx *utx)
658{
Damien Miller348c9b72000-08-15 10:01:22 +1000659 memset(utx, '\0', sizeof(*utx));
Damien Miller8e81ed32000-07-01 13:17:42 +1000660# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000661 line_abbrevname(utx->ut_id, li->line, sizeof(utx->ut_id));
Damien Miller8e81ed32000-07-01 13:17:42 +1000662# endif
andre2ff7b5d2000-06-03 14:57:40 +0000663
664 /* this is done here to keep utmp constants out of loginrec.h */
665 switch (li->type) {
666 case LTYPE_LOGIN:
667 utx->ut_type = USER_PROCESS;
668 break;
669 case LTYPE_LOGOUT:
670 utx->ut_type = DEAD_PROCESS;
671 break;
672 }
andre2ff7b5d2000-06-03 14:57:40 +0000673 line_stripname(utx->ut_line, li->line, sizeof(utx->ut_line));
andre2ff7b5d2000-06-03 14:57:40 +0000674 set_utmpx_time(li, utx);
andre6bb92372000-06-19 08:20:03 +0000675 utx->ut_pid = li->pid;
676
677 if (li->type == LTYPE_LOGOUT)
678 return;
679
Damien Millerdd47aa22000-06-27 11:18:27 +1000680 /*
681 * These fields are only used when logging in, and are blank
Kevin Stevesef4eea92001-02-05 12:42:17 +0000682 * for logouts.
Damien Millerdd47aa22000-06-27 11:18:27 +1000683 */
andre6bb92372000-06-19 08:20:03 +0000684
685 /* strncpy(): Don't necessarily want null termination */
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000686 strncpy(utx->ut_name, li->username, MIN_SIZEOF(utx->ut_name, li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000687# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000688 strncpy(utx->ut_host, li->hostname, MIN_SIZEOF(utx->ut_host, li->hostname));
Damien Millerdd47aa22000-06-27 11:18:27 +1000689# endif
690# ifdef HAVE_ADDR_IN_UTMPX
Damien Millerd6f204d2000-09-23 13:57:27 +1100691 /* this is just a 32-bit IP address */
692 if (li->hostaddr.sa.sa_family == AF_INET)
693 utx->ut_addr = li->hostaddr.sa_in.sin_addr.s_addr;
Damien Millerdd47aa22000-06-27 11:18:27 +1000694# endif
695# ifdef HAVE_SYSLEN_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +0000696 /* ut_syslen is the length of the utx_host string */
697 utx->ut_syslen = MIN(strlen(li->hostname), sizeof(utx->ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +1000698# endif
andre61e67252000-06-04 17:07:49 +0000699}
Damien Millerdd47aa22000-06-27 11:18:27 +1000700#endif /* USE_UTMPX || USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000701
702/**
andre61e67252000-06-04 17:07:49 +0000703 ** Low-level utmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000704 **/
705
706/* FIXME: (ATL) utmp_write_direct needs testing */
andre2ff7b5d2000-06-03 14:57:40 +0000707#ifdef USE_UTMP
708
andre2ff7b5d2000-06-03 14:57:40 +0000709/* if we can, use pututline() etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000710# if !defined(DISABLE_PUTUTLINE) && defined(HAVE_SETUTENT) && \
711 defined(HAVE_PUTUTLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000712# define UTMP_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000713# endif
andre2ff7b5d2000-06-03 14:57:40 +0000714
715
716/* write a utmp entry with the system's help (pututline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000717# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000718static int
andre61e67252000-06-04 17:07:49 +0000719utmp_write_library(struct logininfo *li, struct utmp *ut)
720{
andre2ff7b5d2000-06-03 14:57:40 +0000721 setutent();
722 pututline(ut);
723
Damien Millerdd47aa22000-06-27 11:18:27 +1000724# ifdef HAVE_ENDUTENT
andre2ff7b5d2000-06-03 14:57:40 +0000725 endutent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000726# endif
andre2ff7b5d2000-06-03 14:57:40 +0000727 return 1;
andre61e67252000-06-04 17:07:49 +0000728}
Damien Millerdd47aa22000-06-27 11:18:27 +1000729# else /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000730
731/* write a utmp entry direct to the file */
andre61e67252000-06-04 17:07:49 +0000732/* This is a slightly modification of code in OpenBSD's login.c */
andre2ff7b5d2000-06-03 14:57:40 +0000733static int
andre61e67252000-06-04 17:07:49 +0000734utmp_write_direct(struct logininfo *li, struct utmp *ut)
735{
andre2ff7b5d2000-06-03 14:57:40 +0000736 struct utmp old_ut;
737 register int fd;
738 int tty;
739
andre6bb92372000-06-19 08:20:03 +0000740 /* FIXME: (ATL) ttyslot() needs local implementation */
Damien Miller348c9b72000-08-15 10:01:22 +1000741
Damien Millere5192fa2000-08-29 14:30:37 +1100742#if defined(HAVE_GETTTYENT)
Damien Miller348c9b72000-08-15 10:01:22 +1000743 register struct ttyent *ty;
744
745 tty=0;
746
747 setttyent();
748 while ((struct ttyent *)0 != (ty = getttyent())) {
749 tty++;
750 if (!strncmp(ty->ty_name, ut->ut_line, sizeof(ut->ut_line)))
751 break;
752 }
753 endttyent();
754
755 if((struct ttyent *)0 == ty) {
756 log("utmp_write_entry: tty not found");
757 return(1);
758 }
759#else /* FIXME */
760
andre2ff7b5d2000-06-03 14:57:40 +0000761 tty = ttyslot(); /* seems only to work for /dev/ttyp? style names */
762
Damien Millere5192fa2000-08-29 14:30:37 +1100763#endif /* HAVE_GETTTYENT */
Damien Miller348c9b72000-08-15 10:01:22 +1000764
andre2ff7b5d2000-06-03 14:57:40 +0000765 if (tty > 0 && (fd = open(UTMP_FILE, O_RDWR|O_CREAT, 0644)) >= 0) {
766 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
767 /*
768 * Prevent luser from zero'ing out ut_host.
769 * If the new ut_line is empty but the old one is not
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000770 * and ut_line and ut_name match, preserve the old ut_line.
andre2ff7b5d2000-06-03 14:57:40 +0000771 */
Kevin Stevesef4eea92001-02-05 12:42:17 +0000772 if (atomicio(read, fd, &old_ut, sizeof(old_ut)) == sizeof(old_ut) &&
773 (ut->ut_host[0] == '\0') && (old_ut.ut_host[0] != '\0') &&
774 (strncmp(old_ut.ut_line, ut->ut_line, sizeof(ut->ut_line)) == 0) &&
Damien Miller7a0e5dc2000-07-11 12:15:54 +1000775 (strncmp(old_ut.ut_name, ut->ut_name, sizeof(ut->ut_name)) == 0)) {
andre2ff7b5d2000-06-03 14:57:40 +0000776 (void)memcpy(ut->ut_host, old_ut.ut_host, sizeof(ut->ut_host));
Damien Miller53c5d462000-06-28 00:50:50 +1000777 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000778
andre2ff7b5d2000-06-03 14:57:40 +0000779 (void)lseek(fd, (off_t)(tty * sizeof(struct utmp)), SEEK_SET);
Damien Miller36ccb5c2000-08-09 16:34:27 +1000780 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut))
andre2ff7b5d2000-06-03 14:57:40 +0000781 log("utmp_write_direct: error writing %s: %s",
andre6bb92372000-06-19 08:20:03 +0000782 UTMP_FILE, strerror(errno));
Kevin Stevesef4eea92001-02-05 12:42:17 +0000783
andre2ff7b5d2000-06-03 14:57:40 +0000784 (void)close(fd);
785 return 1;
Damien Miller53c5d462000-06-28 00:50:50 +1000786 } else {
andre2ff7b5d2000-06-03 14:57:40 +0000787 return 0;
Damien Miller53c5d462000-06-28 00:50:50 +1000788 }
andre61e67252000-06-04 17:07:49 +0000789}
Damien Millerdd47aa22000-06-27 11:18:27 +1000790# endif /* UTMP_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000791
792static int
andre61e67252000-06-04 17:07:49 +0000793utmp_perform_login(struct logininfo *li)
794{
andre2ff7b5d2000-06-03 14:57:40 +0000795 struct utmp ut;
796
797 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000798# ifdef UTMP_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000799 if (!utmp_write_library(li, &ut)) {
andre6bb92372000-06-19 08:20:03 +0000800 log("utmp_perform_login: utmp_write_library() failed");
andre2ff7b5d2000-06-03 14:57:40 +0000801 return 0;
802 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000803# else
andre2ff7b5d2000-06-03 14:57:40 +0000804 if (!utmp_write_direct(li, &ut)) {
805 log("utmp_perform_login: utmp_write_direct() failed");
806 return 0;
807 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000808# endif
andre2ff7b5d2000-06-03 14:57:40 +0000809 return 1;
andre61e67252000-06-04 17:07:49 +0000810}
andre2ff7b5d2000-06-03 14:57:40 +0000811
812
813static int
andre61e67252000-06-04 17:07:49 +0000814utmp_perform_logout(struct logininfo *li)
815{
andre2ff7b5d2000-06-03 14:57:40 +0000816 struct utmp ut;
817
andre6bb92372000-06-19 08:20:03 +0000818 construct_utmp(li, &ut);
Damien Millerdd47aa22000-06-27 11:18:27 +1000819# ifdef UTMP_USE_LIBRARY
andre6bb92372000-06-19 08:20:03 +0000820 if (!utmp_write_library(li, &ut)) {
821 log("utmp_perform_logout: utmp_write_library() failed");
822 return 0;
823 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000824# else
andre6bb92372000-06-19 08:20:03 +0000825 if (!utmp_write_direct(li, &ut)) {
826 log("utmp_perform_logout: 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
834int
andre61e67252000-06-04 17:07:49 +0000835utmp_write_entry(struct logininfo *li)
836{
andre2ff7b5d2000-06-03 14:57:40 +0000837 switch(li->type) {
838 case LTYPE_LOGIN:
839 return utmp_perform_login(li);
840
841 case LTYPE_LOGOUT:
842 return utmp_perform_logout(li);
843
844 default:
845 log("utmp_write_entry: invalid type field");
846 return 0;
847 }
andre61e67252000-06-04 17:07:49 +0000848}
Damien Millerdd47aa22000-06-27 11:18:27 +1000849#endif /* USE_UTMP */
andre2ff7b5d2000-06-03 14:57:40 +0000850
851
852/**
andre61e67252000-06-04 17:07:49 +0000853 ** Low-level utmpx functions
andre2ff7b5d2000-06-03 14:57:40 +0000854 **/
855
856/* not much point if we don't want utmpx entries */
857#ifdef USE_UTMPX
858
andre2ff7b5d2000-06-03 14:57:40 +0000859/* if we have the wherewithall, use pututxline etc. */
Damien Millerdd47aa22000-06-27 11:18:27 +1000860# if !defined(DISABLE_PUTUTXLINE) && defined(HAVE_SETUTXENT) && \
861 defined(HAVE_PUTUTXLINE)
andre2ff7b5d2000-06-03 14:57:40 +0000862# define UTMPX_USE_LIBRARY
Damien Millerdd47aa22000-06-27 11:18:27 +1000863# endif
andre2ff7b5d2000-06-03 14:57:40 +0000864
865
866/* write a utmpx entry with the system's help (pututxline() and pals) */
Damien Millerdd47aa22000-06-27 11:18:27 +1000867# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000868static int
andre61e67252000-06-04 17:07:49 +0000869utmpx_write_library(struct logininfo *li, struct utmpx *utx)
870{
andre2ff7b5d2000-06-03 14:57:40 +0000871 setutxent();
872 pututxline(utx);
873
Damien Millerdd47aa22000-06-27 11:18:27 +1000874# ifdef HAVE_ENDUTXENT
andre2ff7b5d2000-06-03 14:57:40 +0000875 endutxent();
Damien Millerdd47aa22000-06-27 11:18:27 +1000876# endif
andre2ff7b5d2000-06-03 14:57:40 +0000877 return 1;
andre61e67252000-06-04 17:07:49 +0000878}
andre2ff7b5d2000-06-03 14:57:40 +0000879
Damien Millerdd47aa22000-06-27 11:18:27 +1000880# else /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000881
882/* write a utmp entry direct to the file */
883static int
andre61e67252000-06-04 17:07:49 +0000884utmpx_write_direct(struct logininfo *li, struct utmpx *utx)
Kevin Stevesef4eea92001-02-05 12:42:17 +0000885{
andre2ff7b5d2000-06-03 14:57:40 +0000886 log("utmpx_write_direct: not implemented!");
887 return 0;
andre61e67252000-06-04 17:07:49 +0000888}
Damien Millerdd47aa22000-06-27 11:18:27 +1000889# endif /* UTMPX_USE_LIBRARY */
andre2ff7b5d2000-06-03 14:57:40 +0000890
891static int
andre61e67252000-06-04 17:07:49 +0000892utmpx_perform_login(struct logininfo *li)
893{
andre2ff7b5d2000-06-03 14:57:40 +0000894 struct utmpx utx;
895
896 construct_utmpx(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000897# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000898 if (!utmpx_write_library(li, &utx)) {
899 log("utmpx_perform_login: utmp_write_library() failed");
900 return 0;
901 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000902# else
andre2ff7b5d2000-06-03 14:57:40 +0000903 if (!utmpx_write_direct(li, &ut)) {
904 log("utmpx_perform_login: utmp_write_direct() failed");
905 return 0;
906 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000907# endif
andre2ff7b5d2000-06-03 14:57:40 +0000908 return 1;
andre61e67252000-06-04 17:07:49 +0000909}
andre2ff7b5d2000-06-03 14:57:40 +0000910
911
912static int
andre61e67252000-06-04 17:07:49 +0000913utmpx_perform_logout(struct logininfo *li)
914{
andre2ff7b5d2000-06-03 14:57:40 +0000915 struct utmpx utx;
916
917 memset(&utx, '\0', sizeof(utx));
918 set_utmpx_time(li, &utx);
919 line_stripname(utx.ut_line, li->line, sizeof(utx.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +1000920# ifdef HAVE_ID_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000921 line_abbrevname(utx.ut_id, li->line, sizeof(utx.ut_id));
Damien Millerdd47aa22000-06-27 11:18:27 +1000922# endif
923# ifdef HAVE_TYPE_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +0000924 utx.ut_type = DEAD_PROCESS;
Damien Millerdd47aa22000-06-27 11:18:27 +1000925# endif
andre2ff7b5d2000-06-03 14:57:40 +0000926
Damien Millerdd47aa22000-06-27 11:18:27 +1000927# ifdef UTMPX_USE_LIBRARY
andre2ff7b5d2000-06-03 14:57:40 +0000928 utmpx_write_library(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000929# else
andre2ff7b5d2000-06-03 14:57:40 +0000930 utmpx_write_direct(li, &utx);
Damien Millerdd47aa22000-06-27 11:18:27 +1000931# endif
andre2ff7b5d2000-06-03 14:57:40 +0000932 return 1;
andre61e67252000-06-04 17:07:49 +0000933}
andre2ff7b5d2000-06-03 14:57:40 +0000934
andre2ff7b5d2000-06-03 14:57:40 +0000935int
andre61e67252000-06-04 17:07:49 +0000936utmpx_write_entry(struct logininfo *li)
937{
andre2ff7b5d2000-06-03 14:57:40 +0000938 switch(li->type) {
939 case LTYPE_LOGIN:
940 return utmpx_perform_login(li);
941 case LTYPE_LOGOUT:
942 return utmpx_perform_logout(li);
943 default:
944 log("utmpx_write_entry: invalid type field");
945 return 0;
946 }
andre61e67252000-06-04 17:07:49 +0000947}
Damien Millerdd47aa22000-06-27 11:18:27 +1000948#endif /* USE_UTMPX */
andre2ff7b5d2000-06-03 14:57:40 +0000949
950
951/**
andre61e67252000-06-04 17:07:49 +0000952 ** Low-level wtmp functions
andre2ff7b5d2000-06-03 14:57:40 +0000953 **/
954
Kevin Stevesef4eea92001-02-05 12:42:17 +0000955#ifdef USE_WTMP
andre2ff7b5d2000-06-03 14:57:40 +0000956
andre2ff7b5d2000-06-03 14:57:40 +0000957/* write a wtmp entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +0000958/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +0000959static int
andre61e67252000-06-04 17:07:49 +0000960wtmp_write(struct logininfo *li, struct utmp *ut)
961{
andre2ff7b5d2000-06-03 14:57:40 +0000962 struct stat buf;
963 int fd, ret = 1;
964
965 if ((fd = open(WTMP_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
966 log("wtmp_write: problem writing %s: %s",
967 WTMP_FILE, strerror(errno));
968 return 0;
969 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000970 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +1000971 if (atomicio(write, fd, ut, sizeof(*ut)) != sizeof(*ut)) {
andre2ff7b5d2000-06-03 14:57:40 +0000972 ftruncate(fd, buf.st_size);
973 log("wtmp_write: problem writing %s: %s",
974 WTMP_FILE, strerror(errno));
975 ret = 0;
976 }
977 (void)close(fd);
andre2ff7b5d2000-06-03 14:57:40 +0000978 return ret;
andre61e67252000-06-04 17:07:49 +0000979}
andre2ff7b5d2000-06-03 14:57:40 +0000980
andre2ff7b5d2000-06-03 14:57:40 +0000981static int
Damien Millerdd47aa22000-06-27 11:18:27 +1000982wtmp_perform_login(struct logininfo *li)
983{
andre2ff7b5d2000-06-03 14:57:40 +0000984 struct utmp ut;
985
986 construct_utmp(li, &ut);
987 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +0000988}
andre2ff7b5d2000-06-03 14:57:40 +0000989
990
991static int
andre61e67252000-06-04 17:07:49 +0000992wtmp_perform_logout(struct logininfo *li)
993{
andre2ff7b5d2000-06-03 14:57:40 +0000994 struct utmp ut;
995
996 construct_utmp(li, &ut);
andre2ff7b5d2000-06-03 14:57:40 +0000997 return wtmp_write(li, &ut);
andre61e67252000-06-04 17:07:49 +0000998}
andre2ff7b5d2000-06-03 14:57:40 +0000999
1000
1001int
andre61e67252000-06-04 17:07:49 +00001002wtmp_write_entry(struct logininfo *li)
1003{
andre2ff7b5d2000-06-03 14:57:40 +00001004 switch(li->type) {
1005 case LTYPE_LOGIN:
1006 return wtmp_perform_login(li);
1007 case LTYPE_LOGOUT:
1008 return wtmp_perform_logout(li);
1009 default:
1010 log("wtmp_write_entry: invalid type field");
1011 return 0;
1012 }
andre61e67252000-06-04 17:07:49 +00001013}
andre2ff7b5d2000-06-03 14:57:40 +00001014
1015
andre6bb92372000-06-19 08:20:03 +00001016/* Notes on fetching login data from wtmp/wtmpx
Kevin Stevesef4eea92001-02-05 12:42:17 +00001017 *
andre6bb92372000-06-19 08:20:03 +00001018 * Logouts are usually recorded with (amongst other things) a blank
1019 * username on a given tty line. However, some systems (HP-UX is one)
1020 * leave all fields set, but change the ut_type field to DEAD_PROCESS.
1021 *
1022 * Since we're only looking for logins here, we know that the username
1023 * must be set correctly. On systems that leave it in, we check for
1024 * ut_type==USER_PROCESS (indicating a login.)
1025 *
1026 * Portability: Some systems may set something other than USER_PROCESS
1027 * to indicate a login process. I don't know of any as I write. Also,
1028 * it's possible that some systems may both leave the username in
1029 * place and not have ut_type.
1030 */
1031
andre6bb92372000-06-19 08:20:03 +00001032/* return true if this wtmp entry indicates a login */
1033static int
1034wtmp_islogin(struct logininfo *li, struct utmp *ut)
1035{
Kevin Stevesef4eea92001-02-05 12:42:17 +00001036 if (strncmp(li->username, ut->ut_name,
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001037 MIN_SIZEOF(li->username, ut->ut_name)) == 0) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001038# ifdef HAVE_TYPE_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001039 if (ut->ut_type & USER_PROCESS)
1040 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001041# else
andre6bb92372000-06-19 08:20:03 +00001042 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001043# endif
andre6bb92372000-06-19 08:20:03 +00001044 }
1045 return 0;
1046}
1047
andre2ff7b5d2000-06-03 14:57:40 +00001048int
andre61e67252000-06-04 17:07:49 +00001049wtmp_get_entry(struct logininfo *li)
1050{
andre2ff7b5d2000-06-03 14:57:40 +00001051 struct stat st;
1052 struct utmp ut;
andre6bb92372000-06-19 08:20:03 +00001053 int fd, found=0;
1054
1055 /* Clear the time entries in our logininfo */
1056 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001057
1058 if ((fd = open(WTMP_FILE, O_RDONLY)) < 0) {
1059 log("wtmp_get_entry: problem opening %s: %s",
1060 WTMP_FILE, strerror(errno));
1061 return 0;
1062 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001063 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001064 log("wtmp_get_entry: couldn't stat %s: %s",
1065 WTMP_FILE, strerror(errno));
1066 close(fd);
1067 return 0;
1068 }
andre2ff7b5d2000-06-03 14:57:40 +00001069
andre6bb92372000-06-19 08:20:03 +00001070 /* Seek to the start of the last struct utmp */
Damien Miller348c9b72000-08-15 10:01:22 +10001071 if (lseek(fd, (off_t)(0 - sizeof(struct utmp)), SEEK_END) == -1) {
andre6bb92372000-06-19 08:20:03 +00001072 /* Looks like we've got a fresh wtmp file */
1073 close(fd);
1074 return 0;
1075 }
1076
1077 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001078 if (atomicio(read, fd, &ut, sizeof(ut)) != sizeof(ut)) {
andre2ff7b5d2000-06-03 14:57:40 +00001079 log("wtmp_get_entry: read of %s failed: %s",
1080 WTMP_FILE, strerror(errno));
1081 close (fd);
1082 return 0;
1083 }
andre6bb92372000-06-19 08:20:03 +00001084 if ( wtmp_islogin(li, &ut) ) {
1085 found = 1;
1086 /* We've already checked for a time in struct
1087 * utmp, in login_getlast(). */
Damien Millerdd47aa22000-06-27 11:18:27 +10001088# ifdef HAVE_TIME_IN_UTMP
andre2ff7b5d2000-06-03 14:57:40 +00001089 li->tv_sec = ut.ut_time;
Damien Millerdd47aa22000-06-27 11:18:27 +10001090# else
andre2ff7b5d2000-06-03 14:57:40 +00001091# if HAVE_TV_IN_UTMP
1092 li->tv_sec = ut.ut_tv.tv_sec;
1093# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001094# endif
andre6bb92372000-06-19 08:20:03 +00001095 line_fullname(li->line, ut.ut_line,
1096 MIN_SIZEOF(li->line, ut.ut_line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001097# ifdef HAVE_HOST_IN_UTMP
andre6bb92372000-06-19 08:20:03 +00001098 strlcpy(li->hostname, ut.ut_host,
1099 MIN_SIZEOF(li->hostname, ut.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001100# endif
andre6bb92372000-06-19 08:20:03 +00001101 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001102 }
andre6bb92372000-06-19 08:20:03 +00001103 /* Seek back 2 x struct utmp */
andre2ff7b5d2000-06-03 14:57:40 +00001104 if (lseek(fd, (off_t)(0-2*sizeof(struct utmp)), SEEK_CUR) == -1) {
andre6bb92372000-06-19 08:20:03 +00001105 /* We've found the start of the file, so quit */
andre2ff7b5d2000-06-03 14:57:40 +00001106 close (fd);
1107 return 0;
1108 }
andre6bb92372000-06-19 08:20:03 +00001109 }
1110
1111 /* We found an entry. Tidy up and return */
1112 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001113 return 1;
andre61e67252000-06-04 17:07:49 +00001114}
Damien Millerdd47aa22000-06-27 11:18:27 +10001115# endif /* USE_WTMP */
andre2ff7b5d2000-06-03 14:57:40 +00001116
1117
1118/**
andre61e67252000-06-04 17:07:49 +00001119 ** Low-level wtmpx functions
andre2ff7b5d2000-06-03 14:57:40 +00001120 **/
1121
1122#ifdef USE_WTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001123/* write a wtmpx entry direct to the end of the file */
andre61e67252000-06-04 17:07:49 +00001124/* This is a slight modification of code in OpenBSD's logwtmp.c */
andre2ff7b5d2000-06-03 14:57:40 +00001125static int
andre61e67252000-06-04 17:07:49 +00001126wtmpx_write(struct logininfo *li, struct utmpx *utx)
1127{
andre2ff7b5d2000-06-03 14:57:40 +00001128 struct stat buf;
1129 int fd, ret = 1;
1130
1131 if ((fd = open(WTMPX_FILE, O_WRONLY|O_APPEND, 0)) < 0) {
1132 log("wtmpx_write: problem opening %s: %s",
1133 WTMPX_FILE, strerror(errno));
1134 return 0;
1135 }
1136
Kevin Stevesef4eea92001-02-05 12:42:17 +00001137 if (fstat(fd, &buf) == 0)
Damien Miller53c5d462000-06-28 00:50:50 +10001138 if (atomicio(write, fd, utx, sizeof(*utx)) != sizeof(*utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001139 ftruncate(fd, buf.st_size);
1140 log("wtmpx_write: problem writing %s: %s",
1141 WTMPX_FILE, strerror(errno));
1142 ret = 0;
1143 }
1144 (void)close(fd);
1145
1146 return ret;
andre61e67252000-06-04 17:07:49 +00001147}
andre2ff7b5d2000-06-03 14:57:40 +00001148
1149
1150static int
andre61e67252000-06-04 17:07:49 +00001151wtmpx_perform_login(struct logininfo *li)
1152{
andre2ff7b5d2000-06-03 14:57:40 +00001153 struct utmpx utx;
1154
1155 construct_utmpx(li, &utx);
1156 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001157}
andre2ff7b5d2000-06-03 14:57:40 +00001158
1159
1160static int
andre61e67252000-06-04 17:07:49 +00001161wtmpx_perform_logout(struct logininfo *li)
1162{
andre2ff7b5d2000-06-03 14:57:40 +00001163 struct utmpx utx;
1164
1165 construct_utmpx(li, &utx);
andre2ff7b5d2000-06-03 14:57:40 +00001166 return wtmpx_write(li, &utx);
andre61e67252000-06-04 17:07:49 +00001167}
andre2ff7b5d2000-06-03 14:57:40 +00001168
1169
1170int
andre61e67252000-06-04 17:07:49 +00001171wtmpx_write_entry(struct logininfo *li)
1172{
andre2ff7b5d2000-06-03 14:57:40 +00001173 switch(li->type) {
1174 case LTYPE_LOGIN:
1175 return wtmpx_perform_login(li);
1176 case LTYPE_LOGOUT:
1177 return wtmpx_perform_logout(li);
1178 default:
1179 log("wtmpx_write_entry: invalid type field");
1180 return 0;
1181 }
andre61e67252000-06-04 17:07:49 +00001182}
andre2ff7b5d2000-06-03 14:57:40 +00001183
andre6bb92372000-06-19 08:20:03 +00001184/* Please see the notes above wtmp_islogin() for information about the
1185 next two functions */
1186
1187/* Return true if this wtmpx entry indicates a login */
1188static int
1189wtmpx_islogin(struct logininfo *li, struct utmpx *utx)
1190{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001191 if ( strncmp(li->username, utx->ut_name,
1192 MIN_SIZEOF(li->username, utx->ut_name)) == 0 ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001193# ifdef HAVE_TYPE_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001194 if (utx->ut_type == USER_PROCESS)
1195 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001196# else
andre6bb92372000-06-19 08:20:03 +00001197 return 1;
Damien Millerdd47aa22000-06-27 11:18:27 +10001198# endif
andre6bb92372000-06-19 08:20:03 +00001199 }
1200 return 0;
1201}
1202
andre2ff7b5d2000-06-03 14:57:40 +00001203
1204int
andre61e67252000-06-04 17:07:49 +00001205wtmpx_get_entry(struct logininfo *li)
1206{
andre2ff7b5d2000-06-03 14:57:40 +00001207 struct stat st;
1208 struct utmpx utx;
andre6bb92372000-06-19 08:20:03 +00001209 int fd, found=0;
1210
1211 /* Clear the time entries */
1212 li->tv_sec = li->tv_usec = 0;
andre2ff7b5d2000-06-03 14:57:40 +00001213
1214 if ((fd = open(WTMPX_FILE, O_RDONLY)) < 0) {
1215 log("wtmpx_get_entry: problem opening %s: %s",
1216 WTMPX_FILE, strerror(errno));
1217 return 0;
1218 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001219 if (fstat(fd, &st) != 0) {
andre2ff7b5d2000-06-03 14:57:40 +00001220 log("wtmpx_get_entry: couldn't stat %s: %s",
1221 WTMP_FILE, strerror(errno));
1222 close(fd);
1223 return 0;
1224 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001225
andre6bb92372000-06-19 08:20:03 +00001226 /* Seek to the start of the last struct utmpx */
1227 if (lseek(fd, (off_t)(0-sizeof(struct utmpx)), SEEK_END) == -1 ) {
1228 /* probably a newly rotated wtmpx file */
1229 close(fd);
1230 return 0;
1231 }
andre2ff7b5d2000-06-03 14:57:40 +00001232
andre6bb92372000-06-19 08:20:03 +00001233 while (!found) {
Damien Miller53c5d462000-06-28 00:50:50 +10001234 if (atomicio(read, fd, &utx, sizeof(utx)) != sizeof(utx)) {
andre2ff7b5d2000-06-03 14:57:40 +00001235 log("wtmpx_get_entry: read of %s failed: %s",
1236 WTMPX_FILE, strerror(errno));
1237 close (fd);
1238 return 0;
1239 }
andre2ff7b5d2000-06-03 14:57:40 +00001240 /* Logouts are recorded as a blank username on a particular line.
1241 * So, we just need to find the username in struct utmpx */
andre6bb92372000-06-19 08:20:03 +00001242 if ( wtmpx_islogin(li, &utx) ) {
Damien Millerdd47aa22000-06-27 11:18:27 +10001243# ifdef HAVE_TV_IN_UTMPX
andre2ff7b5d2000-06-03 14:57:40 +00001244 li->tv_sec = utx.ut_tv.tv_sec;
Damien Millerdd47aa22000-06-27 11:18:27 +10001245# else
andre2ff7b5d2000-06-03 14:57:40 +00001246# ifdef HAVE_TIME_IN_UTMPX
1247 li->tv_sec = utx.ut_time;
1248# endif
Damien Millerdd47aa22000-06-27 11:18:27 +10001249# endif
Damien Miller1a132252000-06-13 21:23:17 +10001250 line_fullname(li->line, utx.ut_line, sizeof(li->line));
Damien Millerdd47aa22000-06-27 11:18:27 +10001251# ifdef HAVE_HOST_IN_UTMPX
andre6bb92372000-06-19 08:20:03 +00001252 strlcpy(li->hostname, utx.ut_host,
1253 MIN_SIZEOF(li->hostname, utx.ut_host));
Damien Millerdd47aa22000-06-27 11:18:27 +10001254# endif
andre6bb92372000-06-19 08:20:03 +00001255 continue;
andre2ff7b5d2000-06-03 14:57:40 +00001256 }
1257 if (lseek(fd, (off_t)(0-2*sizeof(struct utmpx)), SEEK_CUR) == -1) {
1258 close (fd);
1259 return 0;
1260 }
andre6bb92372000-06-19 08:20:03 +00001261 }
1262
1263 close(fd);
andre2ff7b5d2000-06-03 14:57:40 +00001264 return 1;
andre61e67252000-06-04 17:07:49 +00001265}
Damien Millerd5bf3072000-06-07 21:32:13 +10001266#endif /* USE_WTMPX */
andre2ff7b5d2000-06-03 14:57:40 +00001267
andre2ff7b5d2000-06-03 14:57:40 +00001268/**
andre61e67252000-06-04 17:07:49 +00001269 ** Low-level libutil login() functions
andre2ff7b5d2000-06-03 14:57:40 +00001270 **/
1271
1272#ifdef USE_LOGIN
andre2ff7b5d2000-06-03 14:57:40 +00001273static int
andre61e67252000-06-04 17:07:49 +00001274syslogin_perform_login(struct logininfo *li)
1275{
andre2ff7b5d2000-06-03 14:57:40 +00001276 struct utmp *ut;
1277
Damien Miller348c9b72000-08-15 10:01:22 +10001278 if (! (ut = (struct utmp *)malloc(sizeof(*ut)))) {
andre2ff7b5d2000-06-03 14:57:40 +00001279 log("syslogin_perform_login: couldn't malloc()");
1280 return 0;
1281 }
1282 construct_utmp(li, ut);
1283 login(ut);
1284
1285 return 1;
andre61e67252000-06-04 17:07:49 +00001286}
1287
andre2ff7b5d2000-06-03 14:57:40 +00001288static int
andre61e67252000-06-04 17:07:49 +00001289syslogin_perform_logout(struct logininfo *li)
1290{
Damien Millerdd47aa22000-06-27 11:18:27 +10001291# ifdef HAVE_LOGOUT
andre2ff7b5d2000-06-03 14:57:40 +00001292 char line[8];
Kevin Stevesef4eea92001-02-05 12:42:17 +00001293
andre2ff7b5d2000-06-03 14:57:40 +00001294 (void)line_stripname(line, li->line, sizeof(line));
1295
1296 if (!logout(line)) {
1297 log("syslogin_perform_logout: logout() returned an error");
Damien Millerdd47aa22000-06-27 11:18:27 +10001298# ifdef HAVE_LOGWTMP
andre2ff7b5d2000-06-03 14:57:40 +00001299 } else {
1300 logwtmp(line, "", "");
Damien Millerdd47aa22000-06-27 11:18:27 +10001301# endif
Damien Miller9b6d4ab2000-07-02 08:43:18 +10001302 }
andre6bb92372000-06-19 08:20:03 +00001303 /* FIXME: (ATL - if the need arises) What to do if we have
1304 * login, but no logout? what if logout but no logwtmp? All
1305 * routines are in libutil so they should all be there,
1306 * but... */
Damien Millerdd47aa22000-06-27 11:18:27 +10001307# endif
andre2ff7b5d2000-06-03 14:57:40 +00001308 return 1;
andre61e67252000-06-04 17:07:49 +00001309}
andre2ff7b5d2000-06-03 14:57:40 +00001310
andre2ff7b5d2000-06-03 14:57:40 +00001311int
andre61e67252000-06-04 17:07:49 +00001312syslogin_write_entry(struct logininfo *li)
1313{
andre2ff7b5d2000-06-03 14:57:40 +00001314 switch (li->type) {
1315 case LTYPE_LOGIN:
1316 return syslogin_perform_login(li);
1317 case LTYPE_LOGOUT:
1318 return syslogin_perform_logout(li);
1319 default:
1320 log("syslogin_write_entry: Invalid type field");
1321 return 0;
1322 }
andre61e67252000-06-04 17:07:49 +00001323}
Damien Millerd5bf3072000-06-07 21:32:13 +10001324#endif /* USE_LOGIN */
andre2ff7b5d2000-06-03 14:57:40 +00001325
1326/* end of file log-syslogin.c */
1327
andre2ff7b5d2000-06-03 14:57:40 +00001328/**
andre61e67252000-06-04 17:07:49 +00001329 ** Low-level lastlog functions
andre2ff7b5d2000-06-03 14:57:40 +00001330 **/
1331
1332#ifdef USE_LASTLOG
Damien Millerdd47aa22000-06-27 11:18:27 +10001333#define LL_FILE 1
1334#define LL_DIR 2
1335#define LL_OTHER 3
andre2ff7b5d2000-06-03 14:57:40 +00001336
andre2ff7b5d2000-06-03 14:57:40 +00001337static void
andre61e67252000-06-04 17:07:49 +00001338lastlog_construct(struct logininfo *li, struct lastlog *last)
1339{
andre2ff7b5d2000-06-03 14:57:40 +00001340 /* clear the structure */
Damien Miller348c9b72000-08-15 10:01:22 +10001341 memset(last, '\0', sizeof(*last));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001342
Damien Millerdd47aa22000-06-27 11:18:27 +10001343 (void)line_stripname(last->ll_line, li->line, sizeof(last->ll_line));
andre6bb92372000-06-19 08:20:03 +00001344 strlcpy(last->ll_host, li->hostname,
1345 MIN_SIZEOF(last->ll_host, li->hostname));
andre2ff7b5d2000-06-03 14:57:40 +00001346 last->ll_time = li->tv_sec;
andre61e67252000-06-04 17:07:49 +00001347}
andre2ff7b5d2000-06-03 14:57:40 +00001348
andre2ff7b5d2000-06-03 14:57:40 +00001349static int
andre61e67252000-06-04 17:07:49 +00001350lastlog_filetype(char *filename)
1351{
andre2ff7b5d2000-06-03 14:57:40 +00001352 struct stat st;
1353
Damien Millerdd47aa22000-06-27 11:18:27 +10001354 if (stat(LASTLOG_FILE, &st) != 0) {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001355 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
Damien Millerdd47aa22000-06-27 11:18:27 +10001356 strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001357 return 0;
1358 }
andre2ff7b5d2000-06-03 14:57:40 +00001359 if (S_ISDIR(st.st_mode))
1360 return LL_DIR;
1361 else if (S_ISREG(st.st_mode))
1362 return LL_FILE;
1363 else
1364 return LL_OTHER;
andre61e67252000-06-04 17:07:49 +00001365}
andre2ff7b5d2000-06-03 14:57:40 +00001366
1367
1368/* open the file (using filemode) and seek to the login entry */
1369static int
andre61e67252000-06-04 17:07:49 +00001370lastlog_openseek(struct logininfo *li, int *fd, int filemode)
1371{
andre2ff7b5d2000-06-03 14:57:40 +00001372 off_t offset;
1373 int type;
1374 char lastlog_file[1024];
1375
1376 type = lastlog_filetype(LASTLOG_FILE);
1377 switch (type) {
Damien Millerf8af08d2000-06-27 09:40:06 +10001378 case LL_FILE:
1379 strlcpy(lastlog_file, LASTLOG_FILE, sizeof(lastlog_file));
1380 break;
1381 case LL_DIR:
1382 snprintf(lastlog_file, sizeof(lastlog_file), "%s/%s",
1383 LASTLOG_FILE, li->username);
1384 break;
1385 default:
1386 log("lastlog_openseek: %.100s is not a file or directory!",
1387 LASTLOG_FILE);
1388 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001389 }
andre2ff7b5d2000-06-03 14:57:40 +00001390
1391 *fd = open(lastlog_file, filemode);
1392 if ( *fd < 0) {
Damien Miller53c5d462000-06-28 00:50:50 +10001393 debug("lastlog_openseek: Couldn't open %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001394 lastlog_file, strerror(errno));
1395 return 0;
1396 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001397
Damien Millere477ef62000-08-15 10:21:17 +10001398 if (type == LL_FILE) {
1399 /* find this uid's offset in the lastlog file */
1400 offset = (off_t) ( (long)li->uid * sizeof(struct lastlog));
andre2ff7b5d2000-06-03 14:57:40 +00001401
Damien Millere477ef62000-08-15 10:21:17 +10001402 if ( lseek(*fd, offset, SEEK_SET) != offset ) {
1403 log("lastlog_openseek: %s->lseek(): %s",
Kevin Stevesef4eea92001-02-05 12:42:17 +00001404 lastlog_file, strerror(errno));
Damien Millere477ef62000-08-15 10:21:17 +10001405 return 0;
1406 }
andre2ff7b5d2000-06-03 14:57:40 +00001407 }
Kevin Stevesef4eea92001-02-05 12:42:17 +00001408
andre2ff7b5d2000-06-03 14:57:40 +00001409 return 1;
andre61e67252000-06-04 17:07:49 +00001410}
andre2ff7b5d2000-06-03 14:57:40 +00001411
1412static int
andre61e67252000-06-04 17:07:49 +00001413lastlog_perform_login(struct logininfo *li)
1414{
andre2ff7b5d2000-06-03 14:57:40 +00001415 struct lastlog last;
1416 int fd;
1417
1418 /* create our struct lastlog */
1419 lastlog_construct(li, &last);
1420
Damien Millerc1132e72000-08-18 14:08:38 +10001421 if (!lastlog_openseek(li, &fd, O_RDWR|O_CREAT))
1422 return(0);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001423
andre2ff7b5d2000-06-03 14:57:40 +00001424 /* write the entry */
Damien Millerc1132e72000-08-18 14:08:38 +10001425 if (atomicio(write, fd, &last, sizeof(last)) != sizeof(last)) {
1426 close(fd);
1427 log("lastlog_write_filemode: Error writing to %s: %s",
1428 LASTLOG_FILE, strerror(errno));
andre2ff7b5d2000-06-03 14:57:40 +00001429 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001430 }
Damien Millerc1132e72000-08-18 14:08:38 +10001431
1432 close(fd);
1433 return 1;
andre61e67252000-06-04 17:07:49 +00001434}
andre2ff7b5d2000-06-03 14:57:40 +00001435
andre2ff7b5d2000-06-03 14:57:40 +00001436int
andre61e67252000-06-04 17:07:49 +00001437lastlog_write_entry(struct logininfo *li)
1438{
andre2ff7b5d2000-06-03 14:57:40 +00001439 switch(li->type) {
1440 case LTYPE_LOGIN:
1441 return lastlog_perform_login(li);
1442 default:
1443 log("lastlog_write_entry: Invalid type field");
1444 return 0;
1445 }
andre61e67252000-06-04 17:07:49 +00001446}
andre2ff7b5d2000-06-03 14:57:40 +00001447
andre2ff7b5d2000-06-03 14:57:40 +00001448static void
andre61e67252000-06-04 17:07:49 +00001449lastlog_populate_entry(struct logininfo *li, struct lastlog *last)
1450{
andre2ff7b5d2000-06-03 14:57:40 +00001451 line_fullname(li->line, last->ll_line, sizeof(li->line));
Kevin Stevesef4eea92001-02-05 12:42:17 +00001452 strlcpy(li->hostname, last->ll_host,
andre6bb92372000-06-19 08:20:03 +00001453 MIN_SIZEOF(li->hostname, last->ll_host));
andre2ff7b5d2000-06-03 14:57:40 +00001454 li->tv_sec = last->ll_time;
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_get_entry(struct logininfo *li)
1459{
andre2ff7b5d2000-06-03 14:57:40 +00001460 struct lastlog last;
1461 int fd;
1462
1463 if (lastlog_openseek(li, &fd, O_RDONLY)) {
Damien Miller53c5d462000-06-28 00:50:50 +10001464 if (atomicio(read, fd, &last, sizeof(last)) != sizeof(last)) {
1465 log("lastlog_get_entry: Error reading from %s: %s",
andre2ff7b5d2000-06-03 14:57:40 +00001466 LASTLOG_FILE, strerror(errno));
1467 return 0;
1468 } else {
1469 lastlog_populate_entry(li, &last);
1470 return 1;
1471 }
Damien Millerdd47aa22000-06-27 11:18:27 +10001472 } else {
Kevin Stevesef4eea92001-02-05 12:42:17 +00001473 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +10001474 }
andre61e67252000-06-04 17:07:49 +00001475}
Damien Millerd5bf3072000-06-07 21:32:13 +10001476#endif /* USE_LASTLOG */