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
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 off64_t file_offset
;
41 /* Cache for the last read entry. */
42 static struct utmp last_entry
;
45 /* Locking timeout. */
50 /* Do-nothing handler for locking timeout. */
51 static void timeout_handler (int signum
) {};
53 /* LOCK_FILE(fd, type) failure_statement
54 attempts to get a lock on the utmp file referenced by FD. If it fails,
55 the failure_statement is executed, otherwise it is skipped.
57 jumps into the UNLOCK_FILE macro and ensures cleanup of LOCK_FILE.
59 unlocks the utmp file referenced by FD and performs the cleanup of
62 #define LOCK_FILE(fd, type) \
65 struct sigaction action, old_action; \
66 unsigned int old_timeout; \
68 /* Cancel any existing alarm. */ \
69 old_timeout = alarm (0); \
71 /* Establish signal handler. */ \
72 action.sa_handler = timeout_handler; \
73 __sigemptyset (&action.sa_mask); \
74 action.sa_flags = 0; \
75 __sigaction (SIGALRM, &action, &old_action); \
79 /* Try to get the lock. */ \
80 memset (&fl, '\0', sizeof (struct flock)); \
82 fl.l_whence = SEEK_SET; \
83 if (fcntl_not_cancel ((fd), F_SETLKW, &fl) < 0)
85 #define LOCKING_FAILED() \
88 #define UNLOCK_FILE(fd) \
89 /* Unlock the file. */ \
90 fl.l_type = F_UNLCK; \
91 fcntl_not_cancel ((fd), F_SETLKW, &fl); \
94 /* Reset the signal handler and alarm. We must reset the alarm \
95 before resetting the handler so our alarm does not generate a \
96 spurious SIGALRM seen by the user. However, we cannot just set \
97 the user's old alarm before restoring the handler, because then \
98 it's possible our handler could catch the user alarm's SIGARLM \
99 and then the user would never see the signal he expected. */ \
101 __sigaction (SIGALRM, &old_action, NULL); \
102 if (old_timeout != 0) \
103 alarm (old_timeout); \
107 /* Functions defined here. */
108 static int setutent_file (void);
109 static int getutent_r_file (struct utmp
*buffer
, struct utmp
**result
);
110 static int getutid_r_file (const struct utmp
*key
, struct utmp
*buffer
,
111 struct utmp
**result
);
112 static int getutline_r_file (const struct utmp
*key
, struct utmp
*buffer
,
113 struct utmp
**result
);
114 static struct utmp
*pututline_file (const struct utmp
*data
);
115 static void endutent_file (void);
116 static int updwtmp_file (const char *file
, const struct utmp
*utmp
);
118 /* Jump table for file functions. */
119 const struct utfuncs __libc_utmp_file_functions
=
131 #ifndef TRANSFORM_UTMP_FILE_NAME
132 # define TRANSFORM_UTMP_FILE_NAME(file_name) (file_name)
140 const char *file_name
;
143 file_name
= TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name
);
146 # define O_flags O_LARGEFILE | O_CLOEXEC
148 # define O_flags O_LARGEFILE
150 file_fd
= open_not_cancel_2 (file_name
, O_RDWR
| O_flags
);
153 /* Hhm, read-write access did not work. Try read-only. */
154 file_fd
= open_not_cancel_2 (file_name
, O_RDONLY
| O_flags
);
159 #ifndef __ASSUME_O_CLOEXEC
161 if (__have_o_cloexec
<= 0)
164 /* We have to make sure the file is `closed on exec'. */
165 result
= fcntl_not_cancel (file_fd
, F_GETFD
, 0);
169 if (__have_o_cloexec
== 0)
170 __have_o_cloexec
= (result
& FD_CLOEXEC
) ? 1 : -1;
172 if (__have_o_cloexec
< 0)
174 result
= fcntl_not_cancel (file_fd
, F_SETFD
,
175 result
| FD_CLOEXEC
);
180 close_not_cancel_no_status (file_fd
);
187 __lseek64 (file_fd
, 0, SEEK_SET
);
190 /* Make sure the entry won't match. */
191 #if _HAVE_UT_TYPE - 0
192 last_entry
.ut_type
= -1;
194 last_entry
.ut_line
[0] = '\177';
196 last_entry
.ut_id
[0] = '\0';
205 getutent_r_file (struct utmp
*buffer
, struct utmp
**result
)
209 assert (file_fd
>= 0);
211 if (file_offset
== -1l)
218 LOCK_FILE (file_fd
, F_RDLCK
)
224 /* Read the next entry. */
225 nbytes
= read_not_cancel (file_fd
, &last_entry
, sizeof (struct utmp
));
227 UNLOCK_FILE (file_fd
);
229 if (nbytes
!= sizeof (struct utmp
))
237 /* Update position pointer. */
238 file_offset
+= sizeof (struct utmp
);
240 memcpy (buffer
, &last_entry
, sizeof (struct utmp
));
248 internal_getut_r (const struct utmp
*id
, struct utmp
*buffer
,
253 LOCK_FILE (file_fd
, F_RDLCK
)
259 #if _HAVE_UT_TYPE - 0
260 if (id
->ut_type
== RUN_LVL
|| id
->ut_type
== BOOT_TIME
261 || id
->ut_type
== OLD_TIME
|| id
->ut_type
== NEW_TIME
)
263 /* Search for next entry with type RUN_LVL, BOOT_TIME,
264 OLD_TIME, or NEW_TIME. */
268 /* Read the next entry. */
269 if (read_not_cancel (file_fd
, buffer
, sizeof (struct utmp
))
270 != sizeof (struct utmp
))
276 file_offset
+= sizeof (struct utmp
);
278 if (id
->ut_type
== buffer
->ut_type
)
283 #endif /* _HAVE_UT_TYPE */
285 /* Search for the next entry with the specified ID and with type
286 INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS, or DEAD_PROCESS. */
290 /* Read the next entry. */
291 if (read_not_cancel (file_fd
, buffer
, sizeof (struct utmp
))
292 != sizeof (struct utmp
))
298 file_offset
+= sizeof (struct utmp
);
300 if (__utmp_equal (buffer
, id
))
308 UNLOCK_FILE (file_fd
);
314 /* For implementing this function we don't use the getutent_r function
315 because we can avoid the reposition on every new entry this way. */
317 getutid_r_file (const struct utmp
*id
, struct utmp
*buffer
,
318 struct utmp
**result
)
320 assert (file_fd
>= 0);
322 if (file_offset
== -1l)
328 /* We don't have to distinguish whether we can lock the file or
329 whether there is no entry. */
330 bool lock_failed
= false;
331 if (internal_getut_r (id
, &last_entry
, &lock_failed
) < 0)
337 memcpy (buffer
, &last_entry
, sizeof (struct utmp
));
344 /* For implementing this function we don't use the getutent_r function
345 because we can avoid the reposition on every new entry this way. */
347 getutline_r_file (const struct utmp
*line
, struct utmp
*buffer
,
348 struct utmp
**result
)
350 assert (file_fd
>= 0);
352 if (file_offset
== -1l)
358 LOCK_FILE (file_fd
, F_RDLCK
)
366 /* Read the next entry. */
367 if (read_not_cancel (file_fd
, &last_entry
, sizeof (struct utmp
))
368 != sizeof (struct utmp
))
375 file_offset
+= sizeof (struct utmp
);
377 /* Stop if we found a user or login entry. */
379 #if _HAVE_UT_TYPE - 0
380 (last_entry
.ut_type
== USER_PROCESS
381 || last_entry
.ut_type
== LOGIN_PROCESS
)
384 !strncmp (line
->ut_line
, last_entry
.ut_line
, sizeof line
->ut_line
))
388 memcpy (buffer
, &last_entry
, sizeof (struct utmp
));
392 UNLOCK_FILE (file_fd
);
394 return ((*result
== NULL
) ? -1 : 0);
399 pututline_file (const struct utmp
*data
)
405 assert (file_fd
>= 0);
407 /* Find the correct place to insert the data. */
410 #if _HAVE_UT_TYPE - 0
411 (last_entry
.ut_type
== data
->ut_type
412 && (last_entry
.ut_type
== RUN_LVL
413 || last_entry
.ut_type
== BOOT_TIME
414 || last_entry
.ut_type
== OLD_TIME
415 || last_entry
.ut_type
== NEW_TIME
))
418 __utmp_equal (&last_entry
, data
)))
422 bool lock_failed
= false;
423 found
= internal_getut_r (data
, &buffer
, &lock_failed
);
425 if (__builtin_expect (lock_failed
, false))
427 __set_errno (EAGAIN
);
432 LOCK_FILE (file_fd
, F_WRLCK
)
440 /* We append the next entry. */
441 file_offset
= __lseek64 (file_fd
, 0, SEEK_END
);
442 if (file_offset
% sizeof (struct utmp
) != 0)
444 file_offset
-= file_offset
% sizeof (struct utmp
);
445 __ftruncate64 (file_fd
, file_offset
);
447 if (__lseek64 (file_fd
, 0, SEEK_END
) < 0)
456 /* We replace the just read entry. */
457 file_offset
-= sizeof (struct utmp
);
458 __lseek64 (file_fd
, file_offset
, SEEK_SET
);
461 /* Write the new data. */
462 if (write_not_cancel (file_fd
, data
, sizeof (struct utmp
))
463 != sizeof (struct utmp
))
465 /* If we appended a new record this is only partially written.
468 (void) __ftruncate64 (file_fd
, file_offset
);
473 file_offset
+= sizeof (struct utmp
);
474 pbuf
= (struct utmp
*) data
;
478 UNLOCK_FILE (file_fd
);
487 assert (file_fd
>= 0);
489 close_not_cancel_no_status (file_fd
);
495 updwtmp_file (const char *file
, const struct utmp
*utmp
)
501 /* Open WTMP file. */
502 fd
= open_not_cancel_2 (file
, O_WRONLY
| O_LARGEFILE
);
506 LOCK_FILE (fd
, F_WRLCK
)
509 /* Remember original size of log file. */
510 offset
= __lseek64 (fd
, 0, SEEK_END
);
511 if (offset
% sizeof (struct utmp
) != 0)
513 offset
-= offset
% sizeof (struct utmp
);
514 __ftruncate64 (fd
, offset
);
516 if (__lseek64 (fd
, 0, SEEK_END
) < 0)
520 /* Write the entry. If we can't write all the bytes, reset the file
521 size back to the original size. That way, no partial entries
523 if (write_not_cancel (fd
, utmp
, sizeof (struct utmp
))
524 != sizeof (struct utmp
))
526 __ftruncate64 (fd
, offset
);
535 /* Close WTMP file. */
536 close_not_cancel_no_status (fd
);