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