diff options
Diffstat (limited to 'sysdeps/generic/utmp_file.c')
| -rw-r--r-- | sysdeps/generic/utmp_file.c | 499 |
1 files changed, 499 insertions, 0 deletions
diff --git a/sysdeps/generic/utmp_file.c b/sysdeps/generic/utmp_file.c new file mode 100644 index 0000000000..e7743bfac8 --- /dev/null +++ b/sysdeps/generic/utmp_file.c @@ -0,0 +1,499 @@ +/* Copyright (C) 1996-2002, 2003, 2004 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper <drepper@cygnus.com> + and Paul Janzen <pcj@primenet.com>, 1996. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include <assert.h> +#include <errno.h> +#include <fcntl.h> +#include <signal.h> +#include <stdio.h> +#include <string.h> +#include <unistd.h> +#include <utmp.h> +#include <not-cancel.h> + +#include "utmp-private.h" +#include "utmp-equal.h" + + +/* Descriptor for the file and position. */ +static int file_fd = -1; +static off64_t file_offset; + +/* Cache for the last read entry. */ +static struct utmp last_entry; + + +/* Locking timeout. */ +#ifndef TIMEOUT +# define TIMEOUT 1 +#endif + +/* Do-nothing handler for locking timeout. */ +static void timeout_handler (int signum) {}; + +/* LOCK_FILE(fd, type) failure_statement + attempts to get a lock on the utmp file referenced by FD. If it fails, + the failure_statement is executed, otherwise it is skipped. + LOCKING_FAILED() + jumps into the UNLOCK_FILE macro and ensures cleanup of LOCK_FILE. + UNLOCK_FILE(fd) + unlocks the utmp file referenced by FD and performs the cleanup of + LOCK_FILE. + */ +#define LOCK_FILE(fd, type) \ +{ \ + struct flock fl; \ + struct sigaction action, old_action; \ + unsigned int old_timeout; \ + \ + /* Cancel any existing alarm. */ \ + old_timeout = alarm (0); \ + \ + /* Establish signal handler. */ \ + action.sa_handler = timeout_handler; \ + __sigemptyset (&action.sa_mask); \ + action.sa_flags = 0; \ + __sigaction (SIGALRM, &action, &old_action); \ + \ + alarm (TIMEOUT); \ + \ + /* Try to get the lock. */ \ + memset (&fl, '\0', sizeof (struct flock)); \ + fl.l_type = (type); \ + fl.l_whence = SEEK_SET; \ + if (fcntl_not_cancel ((fd), F_SETLKW, &fl) < 0) + +#define LOCKING_FAILED() \ + goto unalarm_return + +#define UNLOCK_FILE(fd) \ + /* Unlock the file. */ \ + fl.l_type = F_UNLCK; \ + fcntl_not_cancel ((fd), F_SETLKW, &fl); \ + \ + unalarm_return: \ + /* Reset the signal handler and alarm. We must reset the alarm \ + before resetting the handler so our alarm does not generate a \ + spurious SIGALRM seen by the user. However, we cannot just set \ + the user's old alarm before restoring the handler, because then \ + it's possible our handler could catch the user alarm's SIGARLM \ + and then the user would never see the signal he expected. */ \ + alarm (0); \ + __sigaction (SIGALRM, &old_action, NULL); \ + if (old_timeout != 0) \ + alarm (old_timeout); \ +} while (0) + + +/* Functions defined here. */ +static int setutent_file (void); +static int getutent_r_file (struct utmp *buffer, struct utmp **result); +static int getutid_r_file (const struct utmp *key, struct utmp *buffer, + struct utmp **result); +static int getutline_r_file (const struct utmp *key, struct utmp *buffer, + struct utmp **result); +static struct utmp *pututline_file (const struct utmp *data); +static void endutent_file (void); +static int updwtmp_file (const char *file, const struct utmp *utmp); + +/* Jump table for file functions. */ +const struct utfuncs __libc_utmp_file_functions = +{ + setutent_file, + getutent_r_file, + getutid_r_file, + getutline_r_file, + pututline_file, + endutent_file, + updwtmp_file +}; + + +#ifndef TRANSFORM_UTMP_FILE_NAME +# define TRANSFORM_UTMP_FILE_NAME(file_name) (file_name) +#endif + +static int +setutent_file (void) +{ + if (file_fd < 0) + { + const char *file_name; + int result; + + file_name = TRANSFORM_UTMP_FILE_NAME (__libc_utmp_file_name); + + file_fd = open_not_cancel_2 (file_name, O_RDWR); + if (file_fd == -1) + { + /* Hhm, read-write access did not work. Try read-only. */ + file_fd = open_not_cancel_2 (file_name, O_RDONLY); + if (file_fd == -1) + return 0; + } + + /* We have to make sure the file is `closed on exec'. */ + result = fcntl_not_cancel (file_fd, F_GETFD, 0); + if (result >= 0) + result = fcntl_not_cancel (file_fd, F_SETFD, result | FD_CLOEXEC); + if (result == -1) + { + close_not_cancel_no_status (file_fd); + return 0; + } + } + + __lseek64 (file_fd, 0, SEEK_SET); + file_offset = 0; + + /* Make sure the entry won't match. */ +#if _HAVE_UT_TYPE - 0 + last_entry.ut_type = -1; +#else + last_entry.ut_line[0] = '\177'; +# if _HAVE_UT_ID - 0 + last_entry.ut_id[0] = '\0'; +# endif +#endif + + return 1; +} + + +static int +getutent_r_file (struct utmp *buffer, struct utmp **result) +{ + ssize_t nbytes; + + assert (file_fd >= 0); + + if (file_offset == -1l) + { + /* Not available. */ + *result = NULL; + return -1; + } + + LOCK_FILE (file_fd, F_RDLCK) + { + nbytes = 0; + LOCKING_FAILED (); + } + + /* Read the next entry. */ + nbytes = read_not_cancel (file_fd, &last_entry, sizeof (struct utmp)); + + UNLOCK_FILE (file_fd); + + if (nbytes != sizeof (struct utmp)) + { + if (nbytes != 0) + file_offset = -1l; + *result = NULL; + return -1; + } + + /* Update position pointer. */ + file_offset += sizeof (struct utmp); + + memcpy (buffer, &last_entry, sizeof (struct utmp)); + *result = buffer; + + return 0; +} + + +static int +internal_getut_r (const struct utmp *id, struct utmp *buffer) +{ + int result = -1; + + LOCK_FILE (file_fd, F_RDLCK) + LOCKING_FAILED (); + +#if _HAVE_UT_TYPE - 0 + if (id->ut_type == RUN_LVL || id->ut_type == BOOT_TIME + || id->ut_type == OLD_TIME || id->ut_type == NEW_TIME) + { + /* Search for next entry with type RUN_LVL, BOOT_TIME, + OLD_TIME, or NEW_TIME. */ + + while (1) + { + /* Read the next entry. */ + if (read_not_cancel (file_fd, buffer, sizeof (struct utmp)) + != sizeof (struct utmp)) + { + __set_errno (ESRCH); + file_offset = -1l; + goto unlock_return; + } + file_offset += sizeof (struct utmp); + + if (id->ut_type == buffer->ut_type) + break; + } + } + else +#endif /* _HAVE_UT_TYPE */ + { + /* Search for the next entry with the specified ID and with type + INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS, or DEAD_PROCESS. */ + + while (1) + { + /* Read the next entry. */ + if (read_not_cancel (file_fd, buffer, sizeof (struct utmp)) + != sizeof (struct utmp)) + { + __set_errno (ESRCH); + file_offset = -1l; + goto unlock_return; + } + file_offset += sizeof (struct utmp); + + if (__utmp_equal (buffer, id)) + break; + } + } + + result = 0; + +unlock_return: + UNLOCK_FILE (file_fd); + + return result; +} + + +/* For implementing this function we don't use the getutent_r function + because we can avoid the reposition on every new entry this way. */ +static int +getutid_r_file (const struct utmp *id, struct utmp *buffer, + struct utmp **result) +{ + assert (file_fd >= 0); + + if (file_offset == -1l) + { + *result = NULL; + return -1; + } + + if (internal_getut_r (id, &last_entry) < 0) + { + *result = NULL; + return -1; + } + + memcpy (buffer, &last_entry, sizeof (struct utmp)); + *result = buffer; + + return 0; +} + + +/* For implementing this function we don't use the getutent_r function + because we can avoid the reposition on every new entry this way. */ +static int +getutline_r_file (const struct utmp *line, struct utmp *buffer, + struct utmp **result) +{ + assert (file_fd >= 0); + + if (file_offset == -1l) + { + *result = NULL; + return -1; + } + + LOCK_FILE (file_fd, F_RDLCK) + { + *result = NULL; + LOCKING_FAILED (); + } + + while (1) + { + /* Read the next entry. */ + if (read_not_cancel (file_fd, &last_entry, sizeof (struct utmp)) + != sizeof (struct utmp)) + { + __set_errno (ESRCH); + file_offset = -1l; + *result = NULL; + goto unlock_return; + } + file_offset += sizeof (struct utmp); + + /* Stop if we found a user or login entry. */ + if ( +#if _HAVE_UT_TYPE - 0 + (last_entry.ut_type == USER_PROCESS + || last_entry.ut_type == LOGIN_PROCESS) + && +#endif + !strncmp (line->ut_line, last_entry.ut_line, sizeof line->ut_line)) + break; + } + + memcpy (buffer, &last_entry, sizeof (struct utmp)); + *result = buffer; + +unlock_return: + UNLOCK_FILE (file_fd); + + return ((*result == NULL) ? -1 : 0); +} + + +static struct utmp * +pututline_file (const struct utmp *data) +{ + struct utmp buffer; + struct utmp *pbuf; + int found; + + assert (file_fd >= 0); + + /* Find the correct place to insert the data. */ + if (file_offset > 0 + && ( +#if _HAVE_UT_TYPE - 0 + (last_entry.ut_type == data->ut_type + && (last_entry.ut_type == RUN_LVL + || last_entry.ut_type == BOOT_TIME + || last_entry.ut_type == OLD_TIME + || last_entry.ut_type == NEW_TIME)) + || +#endif + __utmp_equal (&last_entry, data))) + found = 1; + else + found = internal_getut_r (data, &buffer); + + LOCK_FILE (file_fd, F_WRLCK) + { + pbuf = NULL; + LOCKING_FAILED (); + } + + if (found < 0) + { + /* We append the next entry. */ + file_offset = __lseek64 (file_fd, 0, SEEK_END); + if (file_offset % sizeof (struct utmp) != 0) + { + file_offset -= file_offset % sizeof (struct utmp); + __ftruncate64 (file_fd, file_offset); + + if (__lseek64 (file_fd, 0, SEEK_END) < 0) + { + pbuf = NULL; + goto unlock_return; + } + } + } + else + { + /* We replace the just read entry. */ + file_offset -= sizeof (struct utmp); + __lseek64 (file_fd, file_offset, SEEK_SET); + } + + /* Write the new data. */ + if (write_not_cancel (file_fd, data, sizeof (struct utmp)) + != sizeof (struct utmp)) + { + /* If we appended a new record this is only partially written. + Remove it. */ + if (found < 0) + (void) __ftruncate64 (file_fd, file_offset); + pbuf = NULL; + } + else + { + file_offset += sizeof (struct utmp); + pbuf = (struct utmp *) data; + } + + unlock_return: + UNLOCK_FILE (file_fd); + + return pbuf; +} + + +static void +endutent_file (void) +{ + assert (file_fd >= 0); + + close_not_cancel_no_status (file_fd); + file_fd = -1; +} + + +static int +updwtmp_file (const char *file, const struct utmp *utmp) +{ + int result = -1; + off64_t offset; + int fd; + + /* Open WTMP file. */ + fd = open_not_cancel_2 (file, O_WRONLY); + if (fd < 0) + return -1; + + LOCK_FILE (fd, F_WRLCK) + LOCKING_FAILED (); + + /* Remember original size of log file. */ + offset = __lseek64 (fd, 0, SEEK_END); + if (offset % sizeof (struct utmp) != 0) + { + offset -= offset % sizeof (struct utmp); + __ftruncate64 (fd, offset); + + if (__lseek64 (fd, 0, SEEK_END) < 0) + goto unlock_return; + } + + /* Write the entry. If we can't write all the bytes, reset the file + size back to the original size. That way, no partial entries + will remain. */ + if (write_not_cancel (fd, utmp, sizeof (struct utmp)) + != sizeof (struct utmp)) + { + __ftruncate64 (fd, offset); + goto unlock_return; + } + + result = 0; + +unlock_return: + UNLOCK_FILE (fd); + + /* Close WTMP file. */ + close_not_cancel_no_status (fd); + + return result; +} |