aboutsummaryrefslogtreecommitdiff
path: root/login/utmp_file.c
diff options
context:
space:
mode:
Diffstat (limited to 'login/utmp_file.c')
-rw-r--r--login/utmp_file.c385
1 files changed, 385 insertions, 0 deletions
diff --git a/login/utmp_file.c b/login/utmp_file.c
new file mode 100644
index 0000000000..fff487a0a3
--- /dev/null
+++ b/login/utmp_file.c
@@ -0,0 +1,385 @@
+/* Copyright (C) 1996 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 Library General Public License as
+ published by the Free Software Foundation; either version 2 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <utmp.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+
+#include "utmp-private.h"
+
+
+/* This is the default name. */
+static const char default_file_name[] = _PATH_UTMP;
+
+/* Current file name. */
+static const char *file_name = (const char *) default_file_name;
+
+/* Descriptor for the file and position. */
+static int file_fd = INT_MIN;
+static off_t file_offset;
+
+static struct utmp last_entry;
+
+/* Functions defined here. */
+static int setutent_file (int reset);
+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 utmpname_file (const char *name);
+
+
+/* Jump table for file functions. */
+struct utfuncs __libc_utmp_file_functions =
+{
+ setutent_file,
+ getutent_r_file,
+ getutid_r_file,
+ getutline_r_file,
+ pututline_file,
+ endutent_file,
+ utmpname_file
+};
+
+
+static int
+setutent_file (int reset)
+{
+ if (file_fd == INT_MIN)
+ {
+ file_fd = open (file_name, O_RDWR);
+ if (file_fd == -1)
+ {
+ /* Hhm, read-write access did not work. Try read-only. */
+ file_fd = open (file_name, O_RDONLY);
+ if (file_fd == -1)
+ {
+ perror (_("while opening UTMP file"));
+ return 0;
+ }
+ }
+ file_offset = 0;
+
+ /* Make sure the entry won't match. */
+ last_entry.ut_type = -1;
+ }
+ else if (reset)
+ {
+ /* Remember we are at beginning of file. */
+ file_offset = 0;
+
+ /* Make sure the entry won't match. */
+ last_entry.ut_type = -1;
+ }
+
+ return 1;
+}
+
+
+static void
+endutent_file (void)
+{
+ if (file_fd >= 0)
+ close (file_fd);
+
+ file_fd = INT_MIN;
+}
+
+
+static int
+getutent_r_file (struct utmp *buffer, struct utmp **result)
+{
+ int nbytes;
+
+ /* Open utmp file if not already done. */
+ if (file_fd == INT_MIN)
+ setutent_file (1);
+
+ if (file_fd == -1 || file_offset == -1l)
+ {
+ /* Not available. */
+ *result = NULL;
+ return -1;
+ }
+
+ /* Read the next entry. */
+ flock (file_fd, LOCK_SH);
+ nbytes = read (file_fd, &last_entry, sizeof (struct utmp));
+ flock (file_fd, LOCK_UN);
+
+ if (nbytes!= sizeof (struct utmp))
+ {
+ 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;
+}
+
+
+/* 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)
+{
+ if (file_fd < 0 || file_offset == -1l)
+ {
+ *result = NULL;
+ return -1;
+ }
+
+ while (1)
+ {
+ /* Read the next entry. */
+ if (read (file_fd, &last_entry, sizeof (struct utmp))
+ != sizeof (struct utmp))
+ {
+ __set_errno (ESRCH);
+ file_offset = -1l;
+ *result = NULL;
+ return -1;
+ }
+
+ /* 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;
+
+ file_offset += sizeof (struct utmp);
+ }
+
+ memcpy (buffer, &last_entry, sizeof (struct utmp));
+ *result = buffer;
+
+ return 0;
+}
+
+
+static int
+internal_getutid_r (const struct utmp *id, struct utmp *buffer)
+{
+ 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 (file_fd, buffer, sizeof (struct utmp))
+ != sizeof (struct utmp))
+ {
+ __set_errno (ESRCH);
+ file_offset = -1l;
+ return -1;
+ }
+
+ if (id->ut_type == buffer->ut_type)
+ break;
+
+ file_offset += sizeof (struct utmp);
+ }
+ }
+ else
+ {
+ /* 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 (file_fd, buffer, sizeof (struct utmp))
+ != sizeof (struct utmp))
+ {
+ __set_errno (ESRCH);
+ file_offset = -1l;
+ return -1;
+ }
+ if (( buffer->ut_type == INIT_PROCESS
+ || buffer->ut_type == LOGIN_PROCESS
+ || buffer->ut_type == USER_PROCESS
+ || buffer->ut_type == DEAD_PROCESS)
+ && strncmp (buffer->ut_id, id->ut_id, sizeof id->ut_id) == 0)
+ break;
+
+ file_offset += sizeof (struct utmp);
+ }
+ }
+
+ 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
+getutid_r_file (const struct utmp *id, struct utmp *buffer,
+ struct utmp **result)
+{
+ if (file_fd < 0 || file_offset == -1l)
+ {
+ *result = NULL;
+ return -1;
+ }
+
+ if (internal_getutid_r (id, &last_entry) < 0)
+ {
+ *result = NULL;
+ return -1;
+ }
+
+ memcpy (buffer, &last_entry, sizeof (struct utmp));
+ *result = buffer;
+
+ return 0;
+}
+
+
+static struct utmp *
+pututline_file (const struct utmp *data)
+{
+ struct utmp buffer;
+ struct utmp *pbuf;
+ int found;
+
+ if (file_fd < 0)
+ /* Something went wrong. */
+ return NULL;
+
+ /* Find the correct place to insert the data. */
+ if (file_offset > 0)
+ found = 0;
+ else
+ if ( last_entry.ut_type == RUN_LVL
+ || last_entry.ut_type == BOOT_TIME
+ || last_entry.ut_type == OLD_TIME
+ || last_entry.ut_type == NEW_TIME
+ || (( last_entry.ut_type == INIT_PROCESS
+ || last_entry.ut_type == LOGIN_PROCESS
+ || last_entry.ut_type == USER_PROCESS
+ || last_entry.ut_type == DEAD_PROCESS)
+ && !strncmp (last_entry.ut_id, data->ut_id, sizeof data->ut_id)))
+ found = 1;
+ else
+ found = internal_getutid_r (data, &buffer);
+
+ /* Try to lock the file. */
+ if (flock (file_fd, LOCK_EX | LOCK_NB) < 0 && errno != ENOSYS)
+ {
+ /* Oh, oh. The file is already locked. Wait a bit and try again. */
+ sleep (1);
+
+ /* This time we ignore the error. */
+ (void) flock (file_fd, LOCK_EX | LOCK_NB);
+ }
+
+ if (found < 0)
+ {
+ /* We append the next entry. */
+ file_offset = lseek (file_fd, 0, SEEK_END);
+ if (file_offset % sizeof (struct utmp) != 0)
+ {
+ file_offset -= file_offset % sizeof (struct utmp);
+ ftruncate (file_fd, file_offset);
+
+ if (lseek (file_fd, 0, SEEK_END) < 0)
+ {
+ (void) flock (file_fd, LOCK_UN);
+ return NULL;
+ }
+ }
+ }
+ else
+ {
+ /* We replace the just read entry. */
+ file_offset -= sizeof (struct utmp);
+ lseek (file_fd, file_offset, SEEK_SET);
+ }
+
+ /* Write the new data. */
+ if (write (file_fd, data, sizeof (struct utmp)) != sizeof (struct utmp)
+ /* If we appended a new record this is only partially written.
+ Remove it. */
+ && found < 0)
+ {
+ (void) ftruncate (file_fd, file_offset);
+ pbuf = NULL;
+ }
+ else
+ pbuf = (struct utmp *) data;
+
+ /* And unlock the file. */
+ (void) flock (file_fd, LOCK_UN);
+
+ return pbuf;
+}
+
+
+static int
+utmpname_file (const char *name)
+{
+ if (strcmp (name, file_name) != 0)
+ {
+ if (strcmp (name, default_file_name) == 0)
+ {
+ if (file_name != default_file_name)
+ free ((char *) file_name);
+
+ file_name = default_file_name;
+ }
+ else
+ {
+ char *new_name = __strdup (name);
+ if (new_name == NULL)
+ /* Out of memory. */
+ return -1;
+
+ if (file_name != default_file_name)
+ free ((char *) file_name);
+
+ file_name = new_name;
+ }
+ }
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-11 07:04:40 +0000