blob: 09dea55b9b61015b0cf8042981b4224ffdc67c33 [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
33/**
34 ** 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.
66
67 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 --------------------
85
86 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 -------------------------------
92
93 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!
130
131*/
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
Damien Millere5192fa2000-08-29 14:30:37 +1100146 ** NeXT - M68k/HPPA (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"
163
Damien Millerf5a81472000-09-30 21:34:44 +1100164RCSID("$Id: loginrec.c,v 1.26 2000/09/30 10:34:44 djm Exp $");
andre2ff7b5d2000-06-03 14:57:40 +0000165
166/**
167 ** prototypes for helper functions in this file
168 **/
169
170#if HAVE_UTMP_H
andre2ff7b5d2000-06-03 14:57:40 +0000171void set_utmp_time(struct logininfo *li, struct utmp *ut);
172void construct_utmp(struct logininfo *li, struct utmp *ut);
173#endif
174
175#ifdef HAVE_UTMPX_H
andre2ff7b5d2000-06-03 14:57:40 +0000176void set_utmpx_time(struct logininfo *li, struct utmpx *ut);
177void construct_utmpx(struct logininfo *li, struct utmpx *ut);
178#endif
179
180int utmp_write_entry(struct logininfo *li);
181int utmpx_write_entry(struct logininfo *li);
182int wtmp_write_entry(struct logininfo *li);
183int wtmpx_write_entry(struct logininfo *li);
184int lastlog_write_entry(struct logininfo *li);
185int syslogin_write_entry(struct logininfo *li);
186
187int getlast_entry(struct logininfo *li);
188int lastlog_get_entry(struct logininfo *li);
189int wtmp_get_entry(struct logininfo *li);
190int wtmpx_get_entry(struct logininfo *li);
191
andre6bb92372000-06-19 08:20:03 +0000192/* pick the shortest string */
193#define MIN_SIZEOF(s1,s2) ( sizeof(s1) < sizeof(s2) ? sizeof(s1) : sizeof(s2) )
194
andre2ff7b5d2000-06-03 14:57:40 +0000195/**
196 ** platform-independent login functions
197 **/
198
andre6bb92372000-06-19 08:20:03 +0000199/* login_login(struct logininfo *) -Record a login
200 *
201 * Call with a pointer to a struct logininfo initialised with
202 * login_init_entry() or login_alloc_entry()
203 *
204 * Returns:
205 * >0 if successful
206 * 0 on failure (will use OpenSSH's logging facilities for diagnostics)
207 */
andre61e67252000-06-04 17:07:49 +0000208int
209login_login (struct logininfo *li)
210{
211 li->type = LTYPE_LOGIN;
212 return login_write(li);
213}
214
215
andre6bb92372000-06-19 08:20:03 +0000216/* login_logout(struct logininfo *) - Record a logout
217 *
218 * Call as with login_login()
219 *
220 * Returns:
221 * >0 if successful
222 * 0 on failure (will use OpenSSH's logging facilities for diagnostics)
223 */
andre61e67252000-06-04 17:07:49 +0000224int
225login_logout(struct logininfo *li)
226{
227 li->type = LTYPE_LOGOUT;
228 return login_write(li);
229}
230
andre6bb92372000-06-19 08:20:03 +0000231/* login_get_lastlog_time(int) - Retrieve the last login time
232 *
233 * Retrieve the last login time for the given uid. Will try to use the
234 * system lastlog facilities if they are available, but will fall back
235 * to looking in wtmp/wtmpx if necessary
236 *
237 * Returns:
238 * 0 on failure, or if user has never logged in
239 * Time in seconds from the epoch if successful
240 *
241 * Useful preprocessor symbols:
242 * DISABLE_LASTLOG: If set, *never* even try to retrieve lastlog
243 * info
244 * USE_LASTLOG: If set, indicates the presence of system lastlog
245 * facilities. If this and DISABLE_LASTLOG are not set,
246 * try to retrieve lastlog information from wtmp/wtmpx.
247 */
andre61e67252000-06-04 17:07:49 +0000248unsigned int
249login_get_lastlog_time(const int uid)
250{
251 struct logininfo li;
252
andre6bb92372000-06-19 08:20:03 +0000253 if (login_get_lastlog(&li, uid))
254 return li.tv_sec;
255 else
256 return 0;
andre61e67252000-06-04 17:07:49 +0000257}
258
andre6bb92372000-06-19 08:20:03 +0000259/* login_get_lastlog(struct logininfo *, int) - Retrieve a lastlog entry
260 *
261 * Retrieve a logininfo structure populated (only partially) with
262 * information from the system lastlog data, or from wtmp/wtmpx if no
263 * system lastlog information exists.
264 *
265 * Note this routine must be given a pre-allocated logininfo.
266 *
267 * Returns:
268 * >0: A pointer to your struct logininfo if successful
269 * 0 on failure (will use OpenSSH's logging facilities for diagnostics)
270 *
271 */
andre61e67252000-06-04 17:07:49 +0000272struct logininfo *
273login_get_lastlog(struct logininfo *li, const int uid)
274{
andre6bb92372000-06-19 08:20:03 +0000275 struct passwd *pw;
andre6bb92372000-06-19 08:20:03 +0000276
Damien Miller348c9b72000-08-15 10:01:22 +1000277 memset(li, '\0', sizeof(*li));
andre61e67252000-06-04 17:07:49 +0000278 li->uid = uid;
andre6bb92372000-06-19 08:20:03 +0000279
Damien Miller53c5d462000-06-28 00:50:50 +1000280 /*
281 * If we don't have a 'real' lastlog, we need the username to
andre6bb92372000-06-19 08:20:03 +0000282 * reliably search wtmp(x) for the last login (see
Damien Miller53c5d462000-06-28 00:50:50 +1000283 * wtmp_get_entry().)
284 */
andre6bb92372000-06-19 08:20:03 +0000285 pw = getpwuid(uid);
Damien Millerdd47aa22000-06-27 11:18:27 +1000286 if (pw == NULL)
287 fatal("login_get_lastlog: Cannot find account for uid %i", uid);
288
andre98cabe02000-06-19 09:11:30 +0000289 /* No MIN_SIZEOF here - we absolutely *must not* truncate the
290 * username */
Damien Millerf8af08d2000-06-27 09:40:06 +1000291 strlcpy(li->username, pw->pw_name, sizeof(li->username));
Damien Millerdd47aa22000-06-27 11:18:27 +1000292
andre61e67252000-06-04 17:07:49 +0000293 if (getlast_entry(li))
294 return li;
295 else
Damien Millerdd47aa22000-06-27 11:18:27 +1000296 return NULL;
andre61e67252000-06-04 17:07:49 +0000297}
298
299
andre6bb92372000-06-19 08:20:03 +0000300/* login_alloc_entry(int, char*, char*, char*) - Allocate and initialise
301 * a logininfo structure
302 *
303 * This function creates a new struct logininfo, a data structure
304 * meant to carry the information required to portably record login info.
305 *
306 * Returns a pointer to a newly created struct logininfo. If memory
307 * allocation fails, the program halts.
308 */
andre61e67252000-06-04 17:07:49 +0000309struct
310logininfo *login_alloc_entry(int pid, const char *username,
311 const char *hostname, const char *line)
312{
andre2ff7b5d2000-06-03 14:57:40 +0000313 struct logininfo *newli;
314
Damien Miller348c9b72000-08-15 10:01:22 +1000315 newli = (struct logininfo *) xmalloc (sizeof(*newli));
andre61e67252000-06-04 17:07:49 +0000316 (void)login_init_entry(newli, pid, username, hostname, line);
317 return newli;
318}
andre2ff7b5d2000-06-03 14:57:40 +0000319
320
andre6bb92372000-06-19 08:20:03 +0000321/* login_free_entry(struct logininfo *) - free struct memory */
andre61e67252000-06-04 17:07:49 +0000322void
323login_free_entry(struct logininfo *li)
324{
325 xfree(li);
326}
327
andre2ff7b5d2000-06-03 14:57:40 +0000328
andre6bb92372000-06-19 08:20:03 +0000329/* login_init_entry(struct logininfo *, int, char*, char*, char*)
330 * - initialise a struct logininfo
331 *
332 * Populates a new struct logininfo, a data structure meant to carry
333 * the information required to portably record login info.
334 *
335 * Returns: 1
336 */
andre61e67252000-06-04 17:07:49 +0000337int
338login_init_entry(struct logininfo *li, int pid, const char *username,
339 const char *hostname, const char *line)
340{
Damien Millerf8af08d2000-06-27 09:40:06 +1000341 struct passwd *pw;
342
Damien Miller348c9b72000-08-15 10:01:22 +1000343 memset(li, 0, sizeof(*li));
andre2ff7b5d2000-06-03 14:57:40 +0000344
andre61e67252000-06-04 17:07:49 +0000345 li->pid = pid;
Damien Millerf8af08d2000-06-27 09:40:06 +1000346
andre2ff7b5d2000-06-03 14:57:40 +0000347 /* set the line information */
andre61e67252000-06-04 17:07:49 +0000348 if (line)
andre2ff7b5d2000-06-03 14:57:40 +0000349 line_fullname(li->line, line, sizeof(li->line));
andre2ff7b5d2000-06-03 14:57:40 +0000350
Damien Millerf8af08d2000-06-27 09:40:06 +1000351 if (username) {
andre2ff7b5d2000-06-03 14:57:40 +0000352 strlcpy(li->username, username, sizeof(li->username));
Damien Millerf8af08d2000-06-27 09:40:06 +1000353 pw = getpwnam(li->username);
354 if (pw == NULL)
355 fatal("login_init_entry: Cannot find user \"%s\"", li->username);
356 li->uid = pw->pw_uid;
357 }
Damien Millerdd47aa22000-06-27 11:18:27 +1000358
andre61e67252000-06-04 17:07:49 +0000359 if (hostname)
andre2ff7b5d2000-06-03 14:57:40 +0000360 strlcpy(li->hostname, hostname, sizeof(li->hostname));
Damien Millerf8af08d2000-06-27 09:40:06 +1000361
andre61e67252000-06-04 17:07:49 +0000362 return 1;
andre2ff7b5d2000-06-03 14:57:40 +0000363}
364
andre6bb92372000-06-19 08:20:03 +0000365/* login_set_current_time(struct logininfo *) - set the current time
366 *
367 * Set the current time in a logininfo structure. This function is
368 * meant to eliminate the need to deal with system dependencies for
369 * time handling.
370 */
andre2ff7b5d2000-06-03 14:57:40 +0000371void
andre61e67252000-06-04 17:07:49 +0000372login_set_current_time(struct logininfo *li)
373{
andre2ff7b5d2000-06-03 14:57:40 +0000374 struct timeval tv;
375
376 gettimeofday(&tv, NULL);
Damien Millerf8af08d2000-06-27 09:40:06 +1000377
378 li->tv_sec = tv.tv_sec;
379 li->tv_usec = tv.tv_usec;
andre2ff7b5d2000-06-03 14:57:40 +0000380}
381
andre61e67252000-06-04 17:07:49 +0000382/* copy a sockaddr_* into our logininfo */
andre2ff7b5d2000-06-03 14:57:40 +0000383void
andre61e67252000-06-04 17:07:49 +0000384login_set_addr(struct logininfo *li, const struct sockaddr *sa,
385 const unsigned int sa_size)
386{
387 unsigned int bufsize = sa_size;
388
389 /* make sure we don't overrun our union */
390 if (sizeof(li->hostaddr) < sa_size)
391 bufsize = sizeof(li->hostaddr);
392
393 memcpy((void *)&(li->hostaddr.sa), (const void *)sa, bufsize);
andre2ff7b5d2000-06-03 14:57:40 +0000394}
395
andre2ff7b5d2000-06-03 14:57:40 +0000396
andre61e67252000-06-04 17:07:49 +0000397/**
398 ** login_write: Call low-level recording functions based on autoconf
399 ** results
400 **/
andre2ff7b5d2000-06-03 14:57:40 +0000401int
andre61e67252000-06-04 17:07:49 +0000402login_write (struct logininfo *li)
403{
Damien Millerbac2d8a2000-09-05 16:13:06 +1100404#ifndef HAVE_CYGWIN
andre2ff7b5d2000-06-03 14:57:40 +0000405 if ((int)geteuid() != 0) {
406 log("Attempt to write login records by non-root user (aborting)");
407 return 1;
408 }
Damien Millerbac2d8a2000-09-05 16:13:06 +1100409#endif
Damien Millerdd47aa22000-06-27 11:18:27 +1000410
andre2ff7b5d2000-06-03 14:57:40 +0000411 /* set the timestamp */
412 login_set_current_time(li);
413#ifdef USE_LOGIN
414 syslogin_write_entry(li);
415#endif
416#ifdef USE_LASTLOG
417 if (li->type == LTYPE_LOGIN) {
418 lastlog_write_entry(li);
419 }
420#endif
421#ifdef USE_UTMP
422 utmp_write_entry(li);
423#endif
424#ifdef USE_WTMP
425 wtmp_write_entry(li);
426#endif
427#ifdef USE_UTMPX
428 utmpx_write_entry(li);
429#endif
430#ifdef USE_WTMPX
431 wtmpx_write_entry(li);
432#endif
433 return 0;
434}
435
andre2ff7b5d2000-06-03 14:57:40 +0000436/**
andre61e67252000-06-04 17:07:49 +0000437 ** getlast_entry: Call low-level functions to retrieve the last login
438 ** time.
andre2ff7b5d2000-06-03 14:57:40 +0000439 **/
440
andre61e67252000-06-04 17:07:49 +0000441/* take the uid in li and return the last login time */
442int
443getlast_entry(struct logininfo *li)
444{
445#ifdef USE_LASTLOG
Damien Miller53c5d462000-06-28 00:50:50 +1000446 return(lastlog_get_entry(li));
Damien Millerdd47aa22000-06-27 11:18:27 +1000447#else /* !USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000448
Damien Millerdd47aa22000-06-27 11:18:27 +1000449#ifdef DISABLE_LASTLOG
andreecaabf12000-06-12 22:21:44 +0000450 /* On some systems we shouldn't even try to obtain last login
451 * time, e.g. AIX */
452 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000453# else /* DISABLE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000454 /* Try to retrieve the last login time from wtmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000455# if defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP))
andre61e67252000-06-04 17:07:49 +0000456 /* retrieve last login time from utmp */
Damien Millerdd47aa22000-06-27 11:18:27 +1000457 return (wtmp_get_entry(li));
458# else /* defined(USE_WTMP) && (defined(HAVE_TIME_IN_UTMP) || defined(HAVE_TV_IN_UTMP)) */
andre61e67252000-06-04 17:07:49 +0000459 /* If wtmp isn't available, try wtmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000460# if defined(USE_WTMPX) && (defined(HAVE_TIME_IN_UTMPX) || defined(HAVE_TV_IN_UTMPX))
andre61e67252000-06-04 17:07:49 +0000461 /* retrieve last login time from utmpx */
Damien Millerdd47aa22000-06-27 11:18:27 +1000462 return (wtmpx_get_entry(li));
463# else
andre61e67252000-06-04 17:07:49 +0000464 /* Give up: No means of retrieving last login time */
465 return 0;
Damien Millerdd47aa22000-06-27 11:18:27 +1000466# endif /* USE_WTMPX && (HAVE_TIME_IN_UTMPX || HAVE_TV_IN_UTMPX) */
467# endif /* USE_WTMP && (HAVE_TIME_IN_UTMP || HAVE_TV_IN_UTMP) */
468# endif /* DISABLE_LASTLOG */
469#endif /* USE_LASTLOG */
andre61e67252000-06-04 17:07:49 +0000470}
471
472
473
andre2ff7b5d2000-06-03 14:57:40 +0000474/*
andre61e67252000-06-04 17:07:49 +0000475 * 'line' string utility functions
476 *
477 * These functions process the 'line' string into one of three forms:
478 *
andre2ff7b5d2000-06-03 14:57:40 +0000479 * 1. The full filename (including '/dev')
480 * 2. The stripped name (excluding '/dev')
andre61e67252000-06-04 17:07:49 +0000481 * 3. The abbreviated name (e.g. /dev/ttyp00 -> yp00
482 * /dev/pts/1 -> ts/1 )
andre2ff7b5d2000-06-03 14:57:40 +0000483 *
484 * Form 3 is used on some systems to identify a .tmp.? entry when
485 * attempting to remove it. Typically both addition and removal is
andre61e67252000-06-04 17:07:49 +0000486 * performed by one application - say, sshd - so as long as the choice
487 * uniquely identifies a terminal it's ok.
andre2ff7b5d2000-06-03 14:57:40 +0000488 */
489
490
andre61e67252000-06-04 17:07:49 +0000491/* line_fullname(): add the leading '/dev/' if it doesn't exist make
492 * sure dst has enough space, if not just copy src (ugh) */
andre2ff7b5d2000-06-03 14:57:40 +0000493char *
andre61e67252000-06-04 17:07:49 +0000494line_fullname(char *dst, const char *src, int dstsize)
495{
andre2ff7b5d2000-06-03 14:57:40 +0000496 memset(dst, '\0', dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100497 if ((strncmp(src, "/dev/", 5) == 0) || (dstsize < (strlen(src) + 5))) {
andre2ff7b5d2000-06-03 14:57:40 +0000498 strlcpy(dst, src, dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100499 } else {
Damien Miller1a132252000-06-13 21:23:17 +1000500 strlcpy(dst, "/dev/", dstsize);
andre2ff7b5d2000-06-03 14:57:40 +0000501 strlcat(dst, src, dstsize);
502 }
503 return dst;
504}
505
andre61e67252000-06-04 17:07:49 +0000506/* line_stripname(): strip the leading '/dev' if it exists, return dst */
andre2ff7b5d2000-06-03 14:57:40 +0000507char *
andre61e67252000-06-04 17:07:49 +0000508line_stripname(char *dst, const char *src, int dstsize)
509{
andre2ff7b5d2000-06-03 14:57:40 +0000510 memset(dst, '\0', dstsize);
Damien Millerf5a81472000-09-30 21:34:44 +1100511#ifdef sgi
512 if (strncmp(src, "/dev/tty", 8) == 0)
513 strlcpy(dst, src + 8, dstsize);
514#else
andre2ff7b5d2000-06-03 14:57:40 +0000515 if (strncmp(src, "/dev/", 5) == 0)
Damien Millerf5a81472000-09-30 21:34:44 +1100516 strlcpy(dst, src + 5, dstsize);
517#endif
andre2ff7b5d2000-06-03 14:57:40 +0000518 else
519 strlcpy(dst, src, dstsize);
520 return dst;
andre61e67252000-06-04 17:07:49 +0000521}
522
andre61e67252000-06-04 17:07:49 +0000523/* line_abbrevname(): Return the abbreviated (usually four-character)
524 * form of the line (Just use the last <dstsize> characters of the
525 * full name.)
526 *
527 * NOTE: use strncpy because we do NOT necessarily want zero
528 * termination */
andre2ff7b5d2000-06-03 14:57:40 +0000529char *
Damien Millerdd47aa22000-06-27 11:18:27 +1000530line_abbrevname(char *dst, const char *src, int dstsize)
531{
532 size_t len;
533
andre2ff7b5d2000-06-03 14:57:40 +0000534 memset(dst, '\0', dstsize);
Damien Millerdd47aa22000-06-27 11:18:27 +1000535
Damien Miller8e81ed32000-07-01 13:17:42 +1000536 /* Always skip prefix if present */
Damien Millerf5a81472000-09-30 21:34:44 +1100537#ifdef sgi
538 if (strncmp(src, "/dev/tty", 8) == 0)
539 src += 8;
540#else
Damien Miller8e81ed32000-07-01 13:17:42 +1000541 if (strncmp(src, "/dev/", 5) == 0)
542 src += 5;
Damien Millerf5a81472000-09-30 21:34:44 +1100543#endif
Damien Miller8e81ed32000-07-01 13:17:42 +1000544
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 */
552 strncpy(dst, src, (size_t)dstsize);
Damien Millerdd47aa22000-06-27 11:18:27 +1000553 }
554
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
618 * for logouts.
619 */
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;
Damien Millerdd47aa22000-06-27 11:18:27 +1000630# 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
682 * for logouts.
683 */
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 */
Damien Miller53c5d462000-06-28 00:50:50 +1000772 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 }
778
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));
andre2ff7b5d2000-06-03 14:57:40 +0000783
784 (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)
885{
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
955#ifdef USE_WTMP
956
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 }
andre61e67252000-06-04 17:07:49 +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
1017 *
1018 * 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{
Damien Miller7a0e5dc2000-07-11 12:15:54 +10001036 if (strncmp(li->username, ut->ut_name,
1037 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 }
andre61e67252000-06-04 17:07:49 +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
1137 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 }
andre61e67252000-06-04 17:07:49 +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 }
andre6bb92372000-06-19 08:20:03 +00001225
1226 /* 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];
1293
1294 (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));
andre2ff7b5d2000-06-03 14:57:40 +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) {
1355 log("lastlog_perform_login: Couldn't stat %s: %s", LASTLOG_FILE,
1356 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 }
Damien Millerdd47aa22000-06-27 11:18:27 +10001397
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",
1404 lastlog_file, strerror(errno));
1405 return 0;
1406 }
andre2ff7b5d2000-06-03 14:57:40 +00001407 }
Damien Millere477ef62000-08-15 10:21:17 +10001408
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);
1423
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));
Damien Millerdd47aa22000-06-27 11:18:27 +10001452 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 {
andre2ff7b5d2000-06-03 14:57:40 +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 */