Generic utmp_file.c.
authordrepper <drepper>
Wed, 14 Dec 2005 11:33:40 +0000 (11:33 +0000)
committerdrepper <drepper>
Wed, 14 Dec 2005 11:33:40 +0000 (11:33 +0000)
login/utmp_file.c [new file with mode: 0644]

diff --git a/login/utmp_file.c b/login/utmp_file.c
new file mode 100644 (file)
index 0000000..e7743bf
--- /dev/null
@@ -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;
+}