.
[glibc/history.git] / login / utmp_file.c
blobf32144d1f74daf7f85b84aa0bef1c36fb6bfb5e9
1 /* Copyright (C) 1996-2004, 2007, 2008 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.
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.
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.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA. */
21 #include <assert.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <signal.h>
25 #include <stdbool.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <utmp.h>
30 #include <not-cancel.h>
31 #include <kernel-features.h>
33 #include "utmp-private.h"
34 #include "utmp-equal.h"
37 /* Descriptor for the file and position. */
38 static int file_fd = -1;
39 static bool file_writable;
40 static off64_t file_offset;
42 /* Cache for the last read entry. */
43 static struct utmp last_entry;
46 /* Locking timeout. */
47 #ifndef TIMEOUT
48 # define TIMEOUT 1
49 #endif
51 /* Do-nothing handler for locking timeout. */
52 static void timeout_handler (int signum) {};
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.
63 #define LOCK_FILE(fd, type) \
64 { \
65 struct flock fl; \
66 struct sigaction action, old_action; \
67 unsigned int old_timeout; \
69 /* Cancel any existing alarm. */ \
70 old_timeout = alarm (0); \
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); \
78 alarm (TIMEOUT); \
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)
86 #define LOCKING_FAILED() \
87 goto unalarm_return
89 #define UNLOCK_FILE(fd) \
90 /* Unlock the file. */ \
91 fl.l_type = F_UNLCK; \
92 fcntl_not_cancel ((fd), F_SETLKW, &fl); \
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)
108 /* Functions defined here. */
109 static int setutent_file (void);
110 static int getutent_r_file (struct utmp *buffer, struct utmp **result);
111 static int getutid_r_file (const struct utmp *key, struct utmp *buffer,
112 struct utmp **result);
113 static int getutline_r_file (const struct utmp *key, struct utmp *buffer,
114 struct utmp **result);
115 static struct utmp *pututline_file (const struct utmp *data);
116 static void endutent_file (void);
117 static int updwtmp_file (const char *file, const struct utmp *utmp);
119 /* Jump table for file functions. */
120 const struct utfuncs __libc_utmp_file_functions =
122 setutent_file,
123 getutent_r_file,
124 getutid_r_file,
125 getutline_r_file,
126 pututline_file,
127 endutent_file,
128 updwtmp_file
132 #ifndef TRANSFORM_UTMP_FILE_NAME
133 # define TRANSFORM_UTMP_FILE_NAME(file_name) (file_name)
134 #endif
136 static int
137 setutent_file (void)
139 if (file_fd < 0)
141 const char *file_name;
143 file_name = TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name);
145 #ifdef O_CLOEXEC
146 # define O_flags O_LARGEFILE | O_CLOEXEC
147 #else
148 # define O_flags O_LARGEFILE
149 #endif
150 file_writable = false;
151 file_fd = open_not_cancel_2 (file_name, O_RDONLY | O_flags);
152 if (file_fd == -1)
153 return 0;
155 #ifndef __ASSUME_O_CLOEXEC
156 # ifdef O_CLOEXEC
157 if (__have_o_cloexec <= 0)
158 # endif
160 /* We have to make sure the file is `closed on exec'. */
161 int result = fcntl_not_cancel (file_fd, F_GETFD, 0);
162 if (result >= 0)
164 # ifdef O_CLOEXEC
165 if (__have_o_cloexec == 0)
166 __have_o_cloexec = (result & FD_CLOEXEC) ? 1 : -1;
168 if (__have_o_cloexec < 0)
169 # endif
170 result = fcntl_not_cancel (file_fd, F_SETFD,
171 result | FD_CLOEXEC);
174 if (result == -1)
176 close_not_cancel_no_status (file_fd);
177 return 0;
180 #endif
183 __lseek64 (file_fd, 0, SEEK_SET);
184 file_offset = 0;
186 /* Make sure the entry won't match. */
187 #if _HAVE_UT_TYPE - 0
188 last_entry.ut_type = -1;
189 #else
190 last_entry.ut_line[0] = '\177';
191 # if _HAVE_UT_ID - 0
192 last_entry.ut_id[0] = '\0';
193 # endif
194 #endif
196 return 1;
200 static int
201 getutent_r_file (struct utmp *buffer, struct utmp **result)
203 ssize_t nbytes;
205 assert (file_fd >= 0);
207 if (file_offset == -1l)
209 /* Not available. */
210 *result = NULL;
211 return -1;
214 LOCK_FILE (file_fd, F_RDLCK)
216 nbytes = 0;
217 LOCKING_FAILED ();
220 /* Read the next entry. */
221 nbytes = read_not_cancel (file_fd, &last_entry, sizeof (struct utmp));
223 UNLOCK_FILE (file_fd);
225 if (nbytes != sizeof (struct utmp))
227 if (nbytes != 0)
228 file_offset = -1l;
229 *result = NULL;
230 return -1;
233 /* Update position pointer. */
234 file_offset += sizeof (struct utmp);
236 memcpy (buffer, &last_entry, sizeof (struct utmp));
237 *result = buffer;
239 return 0;
243 static int
244 internal_getut_r (const struct utmp *id, struct utmp *buffer,
245 bool *lock_failed)
247 int result = -1;
249 LOCK_FILE (file_fd, F_RDLCK)
251 *lock_failed = true;
252 LOCKING_FAILED ();
255 #if _HAVE_UT_TYPE - 0
256 if (id->ut_type == RUN_LVL || id->ut_type == BOOT_TIME
257 || id->ut_type == OLD_TIME || id->ut_type == NEW_TIME)
259 /* Search for next entry with type RUN_LVL, BOOT_TIME,
260 OLD_TIME, or NEW_TIME. */
262 while (1)
264 /* Read the next entry. */
265 if (read_not_cancel (file_fd, buffer, sizeof (struct utmp))
266 != sizeof (struct utmp))
268 __set_errno (ESRCH);
269 file_offset = -1l;
270 goto unlock_return;
272 file_offset += sizeof (struct utmp);
274 if (id->ut_type == buffer->ut_type)
275 break;
278 else
279 #endif /* _HAVE_UT_TYPE */
281 /* Search for the next entry with the specified ID and with type
282 INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS, or DEAD_PROCESS. */
284 while (1)
286 /* Read the next entry. */
287 if (read_not_cancel (file_fd, buffer, sizeof (struct utmp))
288 != sizeof (struct utmp))
290 __set_errno (ESRCH);
291 file_offset = -1l;
292 goto unlock_return;
294 file_offset += sizeof (struct utmp);
296 if (__utmp_equal (buffer, id))
297 break;
301 result = 0;
303 unlock_return:
304 UNLOCK_FILE (file_fd);
306 return result;
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. */
312 static int
313 getutid_r_file (const struct utmp *id, struct utmp *buffer,
314 struct utmp **result)
316 assert (file_fd >= 0);
318 if (file_offset == -1l)
320 *result = NULL;
321 return -1;
324 /* We don't have to distinguish whether we can lock the file or
325 whether there is no entry. */
326 bool lock_failed = false;
327 if (internal_getut_r (id, &last_entry, &lock_failed) < 0)
329 *result = NULL;
330 return -1;
333 memcpy (buffer, &last_entry, sizeof (struct utmp));
334 *result = buffer;
336 return 0;
340 /* For implementing this function we don't use the getutent_r function
341 because we can avoid the reposition on every new entry this way. */
342 static int
343 getutline_r_file (const struct utmp *line, struct utmp *buffer,
344 struct utmp **result)
346 assert (file_fd >= 0);
348 if (file_offset == -1l)
350 *result = NULL;
351 return -1;
354 LOCK_FILE (file_fd, F_RDLCK)
356 *result = NULL;
357 LOCKING_FAILED ();
360 while (1)
362 /* Read the next entry. */
363 if (read_not_cancel (file_fd, &last_entry, sizeof (struct utmp))
364 != sizeof (struct utmp))
366 __set_errno (ESRCH);
367 file_offset = -1l;
368 *result = NULL;
369 goto unlock_return;
371 file_offset += sizeof (struct utmp);
373 /* Stop if we found a user or login entry. */
374 if (
375 #if _HAVE_UT_TYPE - 0
376 (last_entry.ut_type == USER_PROCESS
377 || last_entry.ut_type == LOGIN_PROCESS)
379 #endif
380 !strncmp (line->ut_line, last_entry.ut_line, sizeof line->ut_line))
381 break;
384 memcpy (buffer, &last_entry, sizeof (struct utmp));
385 *result = buffer;
387 unlock_return:
388 UNLOCK_FILE (file_fd);
390 return ((*result == NULL) ? -1 : 0);
394 static struct utmp *
395 pututline_file (const struct utmp *data)
397 struct utmp buffer;
398 struct utmp *pbuf;
399 int found;
401 assert (file_fd >= 0);
403 if (! file_writable)
405 /* We must make the file descriptor writable before going on. */
406 const char *file_name = TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name);
408 int new_fd = open_not_cancel_2 (file_name, O_RDWR | O_flags);
409 if (new_fd == -1)
410 return NULL;
412 #ifndef __ASSUME_O_CLOEXEC
413 # ifdef O_CLOEXEC
414 if (__have_o_cloexec <= 0)
415 # endif
417 /* We have to make sure the file is `closed on exec'. */
418 int result = fcntl_not_cancel (file_fd, F_GETFD, 0);
419 if (result >= 0)
421 # ifdef O_CLOEXEC
422 if (__have_o_cloexec == 0)
423 __have_o_cloexec = (result & FD_CLOEXEC) ? 1 : -1;
425 if (__have_o_cloexec < 0)
426 # endif
427 result = fcntl_not_cancel (file_fd, F_SETFD,
428 result | FD_CLOEXEC);
431 if (result == -1)
433 close_not_cancel_no_status (file_fd);
434 return NULL;
437 #endif
439 if (__lseek64 (new_fd, __lseek64 (file_fd, 0, SEEK_CUR), SEEK_SET) == -1
440 || __dup2 (new_fd, file_fd) < 0)
442 close_not_cancel_no_status (new_fd);
443 return NULL;
445 close_not_cancel_no_status (new_fd);
446 file_writable = true;
449 /* Find the correct place to insert the data. */
450 if (file_offset > 0
451 && (
452 #if _HAVE_UT_TYPE - 0
453 (last_entry.ut_type == data->ut_type
454 && (last_entry.ut_type == RUN_LVL
455 || last_entry.ut_type == BOOT_TIME
456 || last_entry.ut_type == OLD_TIME
457 || last_entry.ut_type == NEW_TIME))
459 #endif
460 __utmp_equal (&last_entry, data)))
461 found = 1;
462 else
464 bool lock_failed = false;
465 found = internal_getut_r (data, &buffer, &lock_failed);
467 if (__builtin_expect (lock_failed, false))
469 __set_errno (EAGAIN);
470 return NULL;
474 LOCK_FILE (file_fd, F_WRLCK)
476 pbuf = NULL;
477 LOCKING_FAILED ();
480 if (found < 0)
482 /* We append the next entry. */
483 file_offset = __lseek64 (file_fd, 0, SEEK_END);
484 if (file_offset % sizeof (struct utmp) != 0)
486 file_offset -= file_offset % sizeof (struct utmp);
487 __ftruncate64 (file_fd, file_offset);
489 if (__lseek64 (file_fd, 0, SEEK_END) < 0)
491 pbuf = NULL;
492 goto unlock_return;
496 else
498 /* We replace the just read entry. */
499 file_offset -= sizeof (struct utmp);
500 __lseek64 (file_fd, file_offset, SEEK_SET);
503 /* Write the new data. */
504 if (write_not_cancel (file_fd, data, sizeof (struct utmp))
505 != sizeof (struct utmp))
507 /* If we appended a new record this is only partially written.
508 Remove it. */
509 if (found < 0)
510 (void) __ftruncate64 (file_fd, file_offset);
511 pbuf = NULL;
513 else
515 file_offset += sizeof (struct utmp);
516 pbuf = (struct utmp *) data;
519 unlock_return:
520 UNLOCK_FILE (file_fd);
522 return pbuf;
526 static void
527 endutent_file (void)
529 assert (file_fd >= 0);
531 close_not_cancel_no_status (file_fd);
532 file_fd = -1;
536 static int
537 updwtmp_file (const char *file, const struct utmp *utmp)
539 int result = -1;
540 off64_t offset;
541 int fd;
543 /* Open WTMP file. */
544 fd = open_not_cancel_2 (file, O_WRONLY | O_LARGEFILE);
545 if (fd < 0)
546 return -1;
548 LOCK_FILE (fd, F_WRLCK)
549 LOCKING_FAILED ();
551 /* Remember original size of log file. */
552 offset = __lseek64 (fd, 0, SEEK_END);
553 if (offset % sizeof (struct utmp) != 0)
555 offset -= offset % sizeof (struct utmp);
556 __ftruncate64 (fd, offset);
558 if (__lseek64 (fd, 0, SEEK_END) < 0)
559 goto unlock_return;
562 /* Write the entry. If we can't write all the bytes, reset the file
563 size back to the original size. That way, no partial entries
564 will remain. */
565 if (write_not_cancel (fd, utmp, sizeof (struct utmp))
566 != sizeof (struct utmp))
568 __ftruncate64 (fd, offset);
569 goto unlock_return;
572 result = 0;
574 unlock_return:
575 UNLOCK_FILE (fd);
577 /* Close WTMP file. */
578 close_not_cancel_no_status (fd);
580 return result;