1/* Copyright (C) 1996-2019 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Ulrich Drepper <drepper@cygnus.com>
4 and Paul Janzen <pcj@primenet.com>, 1996.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>. */
19
20#include <assert.h>
21#include <errno.h>
22#include <fcntl.h>
23#include <signal.h>
24#include <stdbool.h>
25#include <stdio.h>
26#include <string.h>
27#include <unistd.h>
28#include <utmp.h>
29#include <not-cancel.h>
30#include <kernel-features.h>
31#include <sigsetops.h>
32#include <not-cancel.h>
33
34#include "utmp-private.h"
35#include "utmp-equal.h"
36
37
38/* Descriptor for the file and position. */
39static int file_fd = -1;
40static bool file_writable;
41static off64_t file_offset;
42
43/* Cache for the last read entry. */
44static struct utmp last_entry;
45
46
47/* Locking timeout. */
48#ifndef TIMEOUT
49# define TIMEOUT 10
50#endif
51
52/* Do-nothing handler for locking timeout. */
53static void timeout_handler (int signum) {};
54
55/* LOCK_FILE(fd, type) failure_statement
56 attempts to get a lock on the utmp file referenced by FD. If it fails,
57 the failure_statement is executed, otherwise it is skipped.
58 LOCKING_FAILED()
59 jumps into the UNLOCK_FILE macro and ensures cleanup of LOCK_FILE.
60 UNLOCK_FILE(fd)
61 unlocks the utmp file referenced by FD and performs the cleanup of
62 LOCK_FILE.
63 */
64#define LOCK_FILE(fd, type) \
65{ \
66 struct flock fl; \
67 struct sigaction action, old_action; \
68 unsigned int old_timeout; \
69 \
70 /* Cancel any existing alarm. */ \
71 old_timeout = alarm (0); \
72 \
73 /* Establish signal handler. */ \
74 action.sa_handler = timeout_handler; \
75 __sigemptyset (&action.sa_mask); \
76 action.sa_flags = 0; \
77 __sigaction (SIGALRM, &action, &old_action); \
78 \
79 alarm (TIMEOUT); \
80 \
81 /* Try to get the lock. */ \
82 memset (&fl, '\0', sizeof (struct flock)); \
83 fl.l_type = (type); \
84 fl.l_whence = SEEK_SET; \
85 if (__fcntl64_nocancel ((fd), F_SETLKW, &fl) < 0)
86
87#define LOCKING_FAILED() \
88 goto unalarm_return
89
90#define UNLOCK_FILE(fd) \
91 /* Unlock the file. */ \
92 fl.l_type = F_UNLCK; \
93 __fcntl64_nocancel ((fd), F_SETLKW, &fl); \
94 \
95 unalarm_return: \
96 /* Reset the signal handler and alarm. We must reset the alarm \
97 before resetting the handler so our alarm does not generate a \
98 spurious SIGALRM seen by the user. However, we cannot just set \
99 the user's old alarm before restoring the handler, because then \
100 it's possible our handler could catch the user alarm's SIGARLM \
101 and then the user would never see the signal he expected. */ \
102 alarm (0); \
103 __sigaction (SIGALRM, &old_action, NULL); \
104 if (old_timeout != 0) \
105 alarm (old_timeout); \
106} while (0)
107
108
109/* Functions defined here. */
110static int setutent_file (void);
111static int getutent_r_file (struct utmp *buffer, struct utmp **result);
112static int getutid_r_file (const struct utmp *key, struct utmp *buffer,
113 struct utmp **result);
114static int getutline_r_file (const struct utmp *key, struct utmp *buffer,
115 struct utmp **result);
116static struct utmp *pututline_file (const struct utmp *data);
117static void endutent_file (void);
118static int updwtmp_file (const char *file, const struct utmp *utmp);
119
120/* Jump table for file functions. */
121const struct utfuncs __libc_utmp_file_functions =
122{
123 setutent_file,
124 getutent_r_file,
125 getutid_r_file,
126 getutline_r_file,
127 pututline_file,
128 endutent_file,
129 updwtmp_file
130};
131
132
133#ifndef TRANSFORM_UTMP_FILE_NAME
134# define TRANSFORM_UTMP_FILE_NAME(file_name) (file_name)
135#endif
136
137static int
138setutent_file (void)
139{
140 if (file_fd < 0)
141 {
142 const char *file_name;
143
144 file_name = TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name);
145
146 file_writable = false;
147 file_fd = __open_nocancel
148 (file_name, O_RDONLY | O_LARGEFILE | O_CLOEXEC);
149 if (file_fd == -1)
150 return 0;
151 }
152
153 __lseek64 (file_fd, 0, SEEK_SET);
154 file_offset = 0;
155
156 /* Make sure the entry won't match. */
157#if _HAVE_UT_TYPE - 0
158 last_entry.ut_type = -1;
159#else
160 last_entry.ut_line[0] = '\177';
161# if _HAVE_UT_ID - 0
162 last_entry.ut_id[0] = '\0';
163# endif
164#endif
165
166 return 1;
167}
168
169
170static int
171getutent_r_file (struct utmp *buffer, struct utmp **result)
172{
173 ssize_t nbytes;
174
175 assert (file_fd >= 0);
176
177 if (file_offset == -1l)
178 {
179 /* Not available. */
180 *result = NULL;
181 return -1;
182 }
183
184 LOCK_FILE (file_fd, F_RDLCK)
185 {
186 nbytes = 0;
187 LOCKING_FAILED ();
188 }
189
190 /* Read the next entry. */
191 nbytes = __read_nocancel (file_fd, &last_entry, sizeof (struct utmp));
192
193 UNLOCK_FILE (file_fd);
194
195 if (nbytes != sizeof (struct utmp))
196 {
197 if (nbytes != 0)
198 file_offset = -1l;
199 *result = NULL;
200 return -1;
201 }
202
203 /* Update position pointer. */
204 file_offset += sizeof (struct utmp);
205
206 memcpy (buffer, &last_entry, sizeof (struct utmp));
207 *result = buffer;
208
209 return 0;
210}
211
212
213static int
214internal_getut_r (const struct utmp *id, struct utmp *buffer,
215 bool *lock_failed)
216{
217 int result = -1;
218
219 LOCK_FILE (file_fd, F_RDLCK)
220 {
221 *lock_failed = true;
222 LOCKING_FAILED ();
223 }
224
225#if _HAVE_UT_TYPE - 0
226 if (id->ut_type == RUN_LVL || id->ut_type == BOOT_TIME
227 || id->ut_type == OLD_TIME || id->ut_type == NEW_TIME)
228 {
229 /* Search for next entry with type RUN_LVL, BOOT_TIME,
230 OLD_TIME, or NEW_TIME. */
231
232 while (1)
233 {
234 /* Read the next entry. */
235 if (__read_nocancel (file_fd, buffer, sizeof (struct utmp))
236 != sizeof (struct utmp))
237 {
238 __set_errno (ESRCH);
239 file_offset = -1l;
240 goto unlock_return;
241 }
242 file_offset += sizeof (struct utmp);
243
244 if (id->ut_type == buffer->ut_type)
245 break;
246 }
247 }
248 else
249#endif /* _HAVE_UT_TYPE */
250 {
251 /* Search for the next entry with the specified ID and with type
252 INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS, or DEAD_PROCESS. */
253
254 while (1)
255 {
256 /* Read the next entry. */
257 if (__read_nocancel (file_fd, buffer, sizeof (struct utmp))
258 != sizeof (struct utmp))
259 {
260 __set_errno (ESRCH);
261 file_offset = -1l;
262 goto unlock_return;
263 }
264 file_offset += sizeof (struct utmp);
265
266 if (__utmp_equal (buffer, id))
267 break;
268 }
269 }
270
271 result = 0;
272
273unlock_return:
274 UNLOCK_FILE (file_fd);
275
276 return result;
277}
278
279
280/* For implementing this function we don't use the getutent_r function
281 because we can avoid the reposition on every new entry this way. */
282static int
283getutid_r_file (const struct utmp *id, struct utmp *buffer,
284 struct utmp **result)
285{
286 assert (file_fd >= 0);
287
288 if (file_offset == -1l)
289 {
290 *result = NULL;
291 return -1;
292 }
293
294 /* We don't have to distinguish whether we can lock the file or
295 whether there is no entry. */
296 bool lock_failed = false;
297 if (internal_getut_r (id, &last_entry, &lock_failed) < 0)
298 {
299 *result = NULL;
300 return -1;
301 }
302
303 memcpy (buffer, &last_entry, sizeof (struct utmp));
304 *result = buffer;
305
306 return 0;
307}
308
309
310/* For implementing this function we don't use the getutent_r function
311 because we can avoid the reposition on every new entry this way. */
312static int
313getutline_r_file (const struct utmp *line, struct utmp *buffer,
314 struct utmp **result)
315{
316 assert (file_fd >= 0);
317
318 if (file_offset == -1l)
319 {
320 *result = NULL;
321 return -1;
322 }
323
324 LOCK_FILE (file_fd, F_RDLCK)
325 {
326 *result = NULL;
327 LOCKING_FAILED ();
328 }
329
330 while (1)
331 {
332 /* Read the next entry. */
333 if (__read_nocancel (file_fd, &last_entry, sizeof (struct utmp))
334 != sizeof (struct utmp))
335 {
336 __set_errno (ESRCH);
337 file_offset = -1l;
338 *result = NULL;
339 goto unlock_return;
340 }
341 file_offset += sizeof (struct utmp);
342
343 /* Stop if we found a user or login entry. */
344 if (
345#if _HAVE_UT_TYPE - 0
346 (last_entry.ut_type == USER_PROCESS
347 || last_entry.ut_type == LOGIN_PROCESS)
348 &&
349#endif
350 !strncmp (line->ut_line, last_entry.ut_line, sizeof line->ut_line))
351 break;
352 }
353
354 memcpy (buffer, &last_entry, sizeof (struct utmp));
355 *result = buffer;
356
357unlock_return:
358 UNLOCK_FILE (file_fd);
359
360 return ((*result == NULL) ? -1 : 0);
361}
362
363
364static struct utmp *
365pututline_file (const struct utmp *data)
366{
367 struct utmp buffer;
368 struct utmp *pbuf;
369 int found;
370
371 assert (file_fd >= 0);
372
373 if (! file_writable)
374 {
375 /* We must make the file descriptor writable before going on. */
376 const char *file_name = TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name);
377
378 int new_fd = __open_nocancel
379 (file_name, O_RDWR | O_LARGEFILE | O_CLOEXEC);
380 if (new_fd == -1)
381 return NULL;
382
383 if (__lseek64 (new_fd, __lseek64 (file_fd, 0, SEEK_CUR), SEEK_SET) == -1
384 || __dup2 (new_fd, file_fd) < 0)
385 {
386 __close_nocancel_nostatus (new_fd);
387 return NULL;
388 }
389 __close_nocancel_nostatus (new_fd);
390 file_writable = true;
391 }
392
393 /* Find the correct place to insert the data. */
394 if (file_offset > 0
395 && (
396#if _HAVE_UT_TYPE - 0
397 (last_entry.ut_type == data->ut_type
398 && (last_entry.ut_type == RUN_LVL
399 || last_entry.ut_type == BOOT_TIME
400 || last_entry.ut_type == OLD_TIME
401 || last_entry.ut_type == NEW_TIME))
402 ||
403#endif
404 __utmp_equal (&last_entry, data)))
405 found = 1;
406 else
407 {
408 bool lock_failed = false;
409 found = internal_getut_r (data, &buffer, &lock_failed);
410
411 if (__builtin_expect (lock_failed, false))
412 {
413 __set_errno (EAGAIN);
414 return NULL;
415 }
416 }
417
418 LOCK_FILE (file_fd, F_WRLCK)
419 {
420 pbuf = NULL;
421 LOCKING_FAILED ();
422 }
423
424 if (found < 0)
425 {
426 /* We append the next entry. */
427 file_offset = __lseek64 (file_fd, 0, SEEK_END);
428 if (file_offset % sizeof (struct utmp) != 0)
429 {
430 file_offset -= file_offset % sizeof (struct utmp);
431 __ftruncate64 (file_fd, file_offset);
432
433 if (__lseek64 (file_fd, 0, SEEK_END) < 0)
434 {
435 pbuf = NULL;
436 goto unlock_return;
437 }
438 }
439 }
440 else
441 {
442 /* We replace the just read entry. */
443 file_offset -= sizeof (struct utmp);
444 __lseek64 (file_fd, file_offset, SEEK_SET);
445 }
446
447 /* Write the new data. */
448 if (__write_nocancel (file_fd, data, sizeof (struct utmp))
449 != sizeof (struct utmp))
450 {
451 /* If we appended a new record this is only partially written.
452 Remove it. */
453 if (found < 0)
454 (void) __ftruncate64 (file_fd, file_offset);
455 pbuf = NULL;
456 }
457 else
458 {
459 file_offset += sizeof (struct utmp);
460 pbuf = (struct utmp *) data;
461 }
462
463 unlock_return:
464 UNLOCK_FILE (file_fd);
465
466 return pbuf;
467}
468
469
470static void
471endutent_file (void)
472{
473 assert (file_fd >= 0);
474
475 __close_nocancel_nostatus (file_fd);
476 file_fd = -1;
477}
478
479
480static int
481updwtmp_file (const char *file, const struct utmp *utmp)
482{
483 int result = -1;
484 off64_t offset;
485 int fd;
486
487 /* Open WTMP file. */
488 fd = __open_nocancel (file, O_WRONLY | O_LARGEFILE);
489 if (fd < 0)
490 return -1;
491
492 LOCK_FILE (fd, F_WRLCK)
493 LOCKING_FAILED ();
494
495 /* Remember original size of log file. */
496 offset = __lseek64 (fd, 0, SEEK_END);
497 if (offset % sizeof (struct utmp) != 0)
498 {
499 offset -= offset % sizeof (struct utmp);
500 __ftruncate64 (fd, offset);
501
502 if (__lseek64 (fd, 0, SEEK_END) < 0)
503 goto unlock_return;
504 }
505
506 /* Write the entry. If we can't write all the bytes, reset the file
507 size back to the original size. That way, no partial entries
508 will remain. */
509 if (__write_nocancel (fd, utmp, sizeof (struct utmp))
510 != sizeof (struct utmp))
511 {
512 __ftruncate64 (fd, offset);
513 goto unlock_return;
514 }
515
516 result = 0;
517
518unlock_return:
519 UNLOCK_FILE (fd);
520
521 /* Close WTMP file. */
522 __close_nocancel_nostatus (fd);
523
524 return result;
525}
526