Update.

1997-05-29 12:48  Ulrich Drepper  <drepper@cygnus.com>

	* io/ftw.c: Complete rewrite.  Add implementation of `nftw'.
	* io/ftw.h: Update for new implementation and XPG4.2.

	* login/Makefile: Update for UTMP daemon implementation.

	Update resolver code to bind-4.9.6-T1A.
	* resolv/Banner: Update.
	* nss/digits_dots.c: Adapt text address matching to T1A.
	* nss/nss_files/files-hosts.c: Always use inet_pton.
	* resolv/base64.c (b64_pton): Follow T1A but don't use this code since
	it would lead to warnings.
	* resolv/gethnamaddr.c (getanswer): Test host name for maximal length
	at several places.
	* resolv/inet_net_pton.c (inet_net_pton_ipv4): Correct typo in comment.
	* resolv/res_comp.c (dn_expand): Check for overflow.
	(dn_comp): Likewise.
	* resolv/res_debug.c (precsize_aton): Better implementation.
	* resolv/res_init.c (res_init): Make `buf' of size MAXDNAME.
	* resolv/res_send.c (res_send): Check for overflow in descriptor set.
	* resolv/nss_dns/dns-host.c (getanswer_r): Test host name for maximal
	length at several places.

1997-05-29 12:51  Mark Kettenis  <kettenis@phys.uva.nl>

	* login/utmp-private.h (struct utfuncs): Add one more parameter
	to updwtmp function.
	Declare all three function jump tables.
	* login/utmp.h: Declare __utmpname.
	* login/getutent_r.c: Remove db backend and provide support for
	utmpd backend.
	* login/login.c: Use `updwtmp' function insteead of writing the
	record ourself.
	* login/logwtmp.c: Move `updwtmp' function to...
	* login/updwtmp.c: ...here.  New file.
	* login/utmp_db.h: Removed.
	* login/utmp_file.c: Add updwtmp function to write to file.
	* login/utmp_daemon.c: New file.  Daemon backend.
	* login/utmpname.c: New file.  Implementation of utmpname function.
	* login/utmpdump.c: New file.  Tool to dump utmp-like files.
	* login/utmpd/connection.c: New file.
	* login/utmpd/database.c: New file.
	* login/utmpd/error.c: New file.
	* login/utmpd/request.c: New file.
	* login/utmpd/utmpd-private.h: New file.
	* login/utmpd/utmpd.c: New file.
	* login/utmpd/utmpd.h: New file.
	* login/utmpd/xtmp.c: New file.
	* login/utmpd/xtmp.h: New file.

1997-05-29 12:28  Jim Meyering  <meyering@eng.ascend.com>

	* time/strftime.c: Correct/normalize indentation in cpp directives.

1997-05-28 20:43  Philip Blundell  <pjb27@cam.ac.uk>

	* nis/nis_error.c: Include <string.h> to fix warning.
	* nis/nis_print.c: Likewise.
	* nis/nss_nisplus/nisplus-hosts.c: Arg 3 of map_v4v6_hostent
	is int* not size_t*.

1997-05-28 21:56  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* math/cmathcalls.h: Correct typo in comment.

	* inet/netinet/icmp6.h: Include <netinet/in.h> for in6_addr.

	* sysdeps/unix/sysv/linux/netinet/ip_fw.h: Include <net/if.h> for
	IFNAMSIZ.

	* sysdeps/unix/sysv/linux/net/ppp_defs.h: Include <time.h> for
	time_t.

	* login/pty.h: Include <ioctl-types.h> for definition of struct
	winsize.

	* misc/regexp.h (compile): Correct typo.

	* argp/argp.h: Put extern before __const in defintion of
	argp_program_bug_address.

1997-05-29 00:20  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/wordsize-32/inttypes.h: Correct names of unsigned fast
	and least types.  Correct names of ?INT_FAST*_{MIN,MAX} macros.
	* sysdeps/wordsize-64/inttypes.h: Likewise.
	Reported by Andreas Jaeger <aj@arthur.rhein-neckar.de>.

1997-05-28 22:51  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/Makefile (make-ioctls-CFLAGS): Use generic
	ttydefaults.h file instead of non-existing version in termios/sys.
	Reported by Zack Weinberg <zack@rabi.phys.columbia.edu>.

	* time/strptime.c (strptime_internal, case 'Y'): Restrict year
	number to four digits and to representable range for 4 byte time_t
	values.
	Patch by H.J. Lu <hjl@lucon.org>.

1997-05-28 18:19  Philip Blundell  <pjb27@cam.ac.uk>

	* posix/execl.c: Include <alloca.h> to avoid warning.

1997-05-27 18:19  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* math/libm-test.c: Implement testing of inlined functions, make
	output nicer, update comments.

	* math/test-idouble.c: New file.  Frontend for double tests of
	inlined functions.
	* math/test-ildoubl.c: New file.  Frontend for long double tests of
	inlined functions.
	* math/test-ifloat.c: New file.  Frontend for float tests of
	inlined functions.

	* math/test-longdouble.c: Rename to...
	* math/test-ldouble.c: ...this.

	* math/Makefile: Add rules for new test programs, change rules for
	renaming of longdouble test.

1997-05-20 15:50  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* sunrpc/rpc/svc.h (__dispatch_fn_t): New.
	(svc_register): Use __dispatch_fn_t in prototype.

1997-05-28 17:02  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/generic/bzero.c (bzero): Fix typo.
	Patch by Witek Wnuk <spider@pest.waw.ids.edu.pl>.

1997-05-27 12:00  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* sysdeps/generic/vtimes.c: Use ISO C declaration style.

	* sysdeps/unix/bsd/ualarm.c: Include <unistd.h> for prototype.

	* sysdeps/generic/memccpy.c: Include <string.h> for prototype.

	* signal/tst-signal.c (handler): Correct function declaration to
	avoid warning.
	* stdlib/testsort.c (compare): Likewise.
	* string/tester.c: Likewise.

1997-05-27 14:16  Miles Bader  <miles@gnu.ai.mit.edu>

	* argp-help.c (argp_args_usage): Supply correct argp to filter_doc.

1997-05-27 17:51  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* db/hash/extern.h, db/hash/hash.c, db/hash/hash.h,
	db/hash/hash_log2.c: Rename __log2 to __hash_log2 to avoid clash
	with libm.

1997-05-27 14:47  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/fpu/e_atan2.c: Fix missing negate.  Use __m81_test
	instead of explicit comparisons.

1997-05-26 18:36  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* inet/netinet/icmp6.h: Remove use of <asm/bitops.h> which has no
	place in a generic header and is no user include file.

1 files changed, 650 insertions, 0 deletions

diff --git a/login/utmpd/request.c b/login/utmpd/request.c
new file mode 100644
index 0000000000..0f68b8ae79
--- /dev/null
+++ b/login/utmpd/request.c
@@ -0,0 +1,650 @@
+/* Copyright (C) 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Mark Kettenis <kettenis@phys.uva.nl>, 1997.
+
+   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 <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <utmp.h>
+
+#include "utmpd.h"
+#include "utmpd-private.h"
+
+
+/* Prototypes for the local functions.  */
+static int process_request (client_connection *connection);
+static int send_reply (client_connection *connect, const reply_header *reply);
+
+static int do_setutent (client_connection *connection);
+static int do_getutent (client_connection *connection);
+static int do_endutent (client_connection *connection);
+static int do_getutline (client_connection *connection);
+static int do_getutid (client_connection *connection);
+static int do_pututline (client_connection *connection);
+static int do_updwtmp (client_connection *connection);
+
+static int proc_utmp_eq (const struct utmp *entry, const struct utmp *match);
+static int internal_getut_r (client_connection *connection,
+			     const struct utmp *id, struct utmp *buffer);
+
+
+/* Read data from the client on CONNECTION.  */
+int
+read_data (client_connection *connection)
+{
+  ssize_t nbytes;
+
+  assert (connection);
+  assert ((connection->read_end - connection->read_ptr) > 0);
+
+  /* Read data.  */
+  nbytes = read (connection->sock, connection->read_ptr,
+		 connection->read_end - connection->read_ptr);
+  if (nbytes > 0)
+    {
+      size_t total_bytes;
+
+      /* Update read pointer.  */
+      connection->read_ptr += nbytes;
+
+      /* Check if we have a complete request header.  */
+      total_bytes = connection->read_ptr - connection->read_base;
+      if (total_bytes >= sizeof (request_header))
+	{
+	  request_header *header;
+
+	  /* Check if we have a complete request.  */
+	  header = (request_header *)connection->read_base;
+	  if (total_bytes >= header->size)
+	    {
+	      /* Process the request.  */
+	      if (process_request (connection) < 0)
+		return -1;
+
+	      /* Adjust read pointer, and flush buffer.  */
+	      connection->read_ptr -= header->size;
+	      memmove (connection->read_base,
+		       connection->read_base + header->size,
+		       connection->read_ptr - connection->read_base);
+	    }
+	}
+
+      return 0;
+    }
+
+  if (nbytes < 0)
+    error (0, errno, "cannot read from client");
+
+  return -1;
+}
+
+
+/* Write data to the client on CONNECTION.  */
+int
+write_data (client_connection *connection)
+{
+  ssize_t nbytes;
+
+  assert (connection);
+  assert ((connection->write_ptr - connection->write_base) > 0);
+
+  /* Write data.  */
+  nbytes = write (connection->sock, connection->write_base,
+		  connection->write_ptr - connection->write_base);
+  if (nbytes > 0)
+    {
+      /* Adjust write pointer and flush buffer.  */
+      connection->write_ptr -= nbytes;
+      memmove (connection->write_base, connection->write_base + nbytes,
+	       connection->write_ptr - connection->write_base);
+
+      return 0;
+    }
+
+  if (nbytes < 0)
+    error (0, errno, "cannot write to client");
+
+  return -1;
+}
+
+
+/* Process the request received on CONNECTION.  Returns 0 if
+   successful, -1 if not.  */
+static int
+process_request (client_connection *connection)
+{
+  request_header *header;
+
+  assert (connection);
+  assert (connection->read_base);
+
+  header = (request_header *)connection->read_base;
+  if (header->version != UTMPD_VERSION)
+    {
+      warning (EINVAL, "invalid protocol version");
+      return -1;
+    }
+
+  switch (header->type)
+    {
+    case UTMPD_REQ_SETUTENT:	return do_setutent (connection);
+    case UTMPD_REQ_GETUTENT:	return do_getutent (connection);
+    case UTMPD_REQ_ENDUTENT:	return do_endutent (connection);
+    case UTMPD_REQ_GETUTLINE:	return do_getutline (connection);
+    case UTMPD_REQ_GETUTID:	return do_getutid (connection);
+    case UTMPD_REQ_PUTUTLINE:	return do_pututline (connection);
+    case UTMPD_REQ_UPDWTMP:	return do_updwtmp (connection);
+    default:
+      warning (EINVAL, "invalid request type");
+      return -1;
+    }
+}
+
+
+/* Send the reply specified by HEADER to the client on CONNECTION.
+   Returns 0 if successful, -1 if not.  */
+static int
+send_reply (client_connection *connection, const reply_header *reply)
+{
+  /* Check if the reply fits in the buffer.  */
+  if ((size_t) (connection->write_end - connection->write_ptr) < reply->size)
+    {
+      error (0, 0, "buffer overflow");
+      return -1;
+    }
+
+  /* Copy reply to buffer, and adjust write pointer.  */
+  memcpy (connection->write_ptr, reply, reply->size);
+  connection->write_ptr += reply->size;
+
+  return 0;
+}
+
+
+static int
+do_setutent (client_connection *connection)
+{
+  setutent_request *request;
+  setutent_reply reply;
+
+  request = (setutent_request *)connection->read_base;
+  if (request->header.size != sizeof (setutent_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Initialize reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (setutent_reply);
+  reply.header.type = UTMPD_REQ_SETUTENT;
+
+  /* Select database.  */
+  if (!strncmp (request->file, _PATH_UTMP, sizeof request->file))
+    connection->database = utmp_db;
+  else
+    {
+      errno = EINVAL;
+      goto return_error;
+    }
+
+  /* Initialize position pointer.  */
+  connection->position = 0;
+
+#if _HAVE_UT_TYPE - 0
+  /* Make sure the entry won't match.  */
+  connection->last_entry.ut_type = -1;
+#endif
+
+  reply.errnum = 0;
+  reply.result = 0;
+  return send_reply (connection, &reply.header);
+
+return_error:
+  reply.errnum = errno;
+  reply.result = -1;
+  return send_reply (connection, &reply.header);
+}
+
+
+static int
+do_getutent (client_connection *connection)
+{
+  getutent_request *request;
+  getutent_reply reply;
+
+  request = (getutent_request *)connection->read_base;
+  if (request->header.size != sizeof (getutent_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Initialize reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (getutent_reply);
+  reply.header.type = UTMPD_REQ_GETUTENT;
+
+  if (connection->database == NULL || connection->position == -1)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Make sure we're in synch with the ordinary file.  */
+  if (synchronize_database (connection->database) < 0)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Read the next entry from the database.  */
+  if (read_entry (connection->database, connection->position,
+		  &connection->last_entry) < 0)
+    {
+      connection->position = -1;
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Update position pointer.  */
+  connection->position++;
+
+  memcpy (&reply.entry, &connection->last_entry, sizeof (struct utmp));
+  reply.errnum = 0;
+  reply.result = 0;
+  return send_reply (connection, (reply_header *)&reply);
+
+return_error:
+  memset (&reply.entry, 0, sizeof (struct utmp));
+  reply.errnum = errno;
+  reply.result = -1;
+  return send_reply (connection, &reply.header);
+}
+
+
+static int
+do_endutent (client_connection *connection)
+{
+  endutent_request *request;
+  endutent_reply reply;
+
+  request = (endutent_request *)connection->read_base;
+  if (request->header.size != sizeof (endutent_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Deselect database.  */
+  connection->database = NULL;
+
+  /* Formulate reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (endutent_reply);
+  reply.header.type = UTMPD_REQ_ENDUTENT;
+  reply.errnum = 0;
+  reply.result = 0;
+
+  return send_reply (connection, &reply.header);
+}
+
+
+static int
+do_getutline (client_connection *connection)
+{
+  getutline_request *request;
+  getutline_reply reply;
+
+  request = (getutline_request *)connection->read_base;
+  if (request->header.size != sizeof (getutline_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Initialize reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (getutline_reply);
+  reply.header.type = UTMPD_REQ_GETUTLINE;
+
+  if (connection->database == NULL || connection->position == -1)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Make sure we're in synch with the ordinary file.  */
+  if (synchronize_database (connection->database) < 0)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  while (1)
+    {
+      /* Read the next entry.  */
+      if (read_entry (connection->database, connection->position,
+		      &connection->last_entry) < 0)
+	{
+	  connection->position = -1;
+	  errno = ESRCH;
+	  goto return_error;
+	}
+      connection->position++;
+
+      /* Stop if we found a user or login entry.  */
+      if (
+#if _HAVE_UT_TYPE - 0
+	  (connection->last_entry.ut_type == USER_PROCESS
+	   || connection->last_entry.ut_type == LOGIN_PROCESS)
+	  &&
+#endif
+	  !strncmp (request->line.ut_line, connection->last_entry.ut_line,
+		    sizeof request->line.ut_line))
+	break;
+    }
+
+  memcpy (&reply.entry, &connection->last_entry, sizeof (struct utmp));
+  reply.errnum = 0;
+  reply.result = 0;
+  return send_reply (connection, &reply.header);
+
+return_error:
+  memset (&reply.entry, 0, sizeof (struct utmp));
+  reply.errnum = errno;
+  reply.result = -1;
+  return send_reply (connection, &reply.header);
+}
+
+
+static int
+do_getutid (client_connection *connection)
+{
+  getutid_request *request;
+  getutid_reply reply;
+
+  request = (getutid_request *)connection->read_base;
+  if (request->header.size != sizeof (getutid_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Initialize reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (getutid_reply);
+  reply.header.type = UTMPD_REQ_GETUTID;
+
+  if (connection->database == NULL || connection->position == -1)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Make sure we're in synch with the ordinary file.  */
+  if (synchronize_database (connection->database) < 0)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  if (internal_getut_r (connection, &request->id,
+			&connection->last_entry) < 0)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  reply.errnum = 0;
+  reply.result = 0;
+  memcpy (&reply.entry, &connection->last_entry, sizeof (struct utmp));
+  return send_reply (connection, &reply.header);
+
+return_error:
+  memset (&reply.entry, 0, sizeof (struct utmp));
+  reply.errnum = errno;
+  reply.result = -1;
+  return send_reply (connection, &reply.header);
+}
+
+
+static int
+do_pututline (client_connection *connection)
+{
+  pututline_request *request;
+  pututline_reply reply;
+  struct utmp buffer;
+  int found;
+
+  request = (pututline_request *)connection->read_base;
+  if (request->header.size != sizeof (pututline_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Initialize reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (pututline_reply);
+  reply.header.type = UTMPD_REQ_PUTUTLINE;
+
+  if (!(connection->access & W_OK))
+    {
+      errno = EPERM;
+      goto return_error;
+    }
+
+  if (connection->database == NULL || connection->position == -1)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Make sure we're in synch with the ordinary file.  */
+  if (synchronize_database (connection->database) < 0)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Find the correct place to insert the data.  */
+  if (connection->position > 0
+    && (
+#if _HAVE_UT_TYPE - 0
+	(connection->last_entry.ut_type == request->utmp.ut_type
+	 && (connection->last_entry.ut_type == RUN_LVL
+	     || connection->last_entry.ut_type == BOOT_TIME
+	     || connection->last_entry.ut_type == OLD_TIME
+	     || connection->last_entry.ut_type == NEW_TIME))
+	||
+#endif
+	proc_utmp_eq (&connection->last_entry, &request->utmp)))
+    found = 1;
+  else
+    found = internal_getut_r (connection, &request->utmp, &buffer);
+
+  if (found < 0)
+    {
+      /* We append the next entry.  */
+      connection->position =
+	append_entry (connection->database, &request->utmp);
+      if (connection->position < 0)
+	goto return_error;
+    }
+  else
+    {
+      /* We replace the just read entry.  */
+      connection->position--;
+      if (write_entry (connection->database, connection->position,
+		       &request->utmp) < 0)
+	goto return_error;
+    }
+
+  /* Write the entry to the compatibility file.  */
+  write_old_entry (connection->database, connection->position, &request->utmp);
+
+  /* Update position pointer.  */
+  connection->position++;
+
+  reply.errnum = 0;
+  reply.result = 0;
+  return send_reply (connection, &reply.header);
+
+return_error:
+  reply.errnum = errno;
+  reply.result = -1;
+  return send_reply (connection, &reply.header);
+}
+
+
+static int
+do_updwtmp (client_connection *connection)
+{
+  updwtmp_request *request;
+  updwtmp_reply reply;
+  utmp_database *database;
+
+  request = (updwtmp_request *)connection->read_base;
+  if (request->header.size != sizeof (updwtmp_request))
+    {
+      warning (EINVAL, "invalid request size");
+      return -1;
+    }
+
+  /* Initialize reply.  */
+  reply.header.version = UTMPD_VERSION;
+  reply.header.size = sizeof (updwtmp_reply);
+  reply.header.type = UTMPD_REQ_UPDWTMP;
+
+  if (!(connection->access & W_OK))
+    {
+      errno = EPERM;
+      goto return_error;
+    }
+
+  /* Select database.  */
+  if (!strncmp (request->file, _PATH_UTMP, sizeof request->file))
+    database = utmp_db;
+  else
+    {
+      errno = EINVAL;
+      goto return_error;
+    }
+
+  /* Make sure we're in synch with the ordinary file.  */
+  if (synchronize_database (database) < 0)
+    {
+      errno = ESRCH;
+      goto return_error;
+    }
+
+  /* Append the entry.  */
+  if (append_entry (database, &request->utmp) < 0)
+    goto return_error;
+
+  reply.errnum = 0;
+  reply.result = 0;
+  return send_reply (connection, &reply.header);
+
+return_error:
+  reply.errnum = errno;
+  reply.result = -1;
+  return send_reply (connection, &reply.header);
+}
+
+
+/* This function is identical to the one in login/utmp_file.c.  */
+static int
+proc_utmp_eq (const struct utmp *entry, const struct utmp *match)
+{
+  return
+    (
+#if _HAVE_UT_TYPE - 0
+     (entry->ut_type == INIT_PROCESS
+      || entry->ut_type == LOGIN_PROCESS
+      || entry->ut_type == USER_PROCESS
+      || entry->ut_type == DEAD_PROCESS)
+     &&
+     (match->ut_type == INIT_PROCESS
+      || match->ut_type == LOGIN_PROCESS
+      || match->ut_type == USER_PROCESS
+      || match->ut_type == DEAD_PROCESS)
+     &&
+#endif
+#if _HAVE_UT_ID - 0
+     strncmp (entry->ut_id, match->ut_id, sizeof match->ut_id) == 0
+#else
+     strncmp (entry->ut_line, match->ut_line, sizeof match->ut_line) == 0
+#endif
+     );
+}
+
+
+/* This function is derived from the one in login/utmp_file.c.  */
+static int
+internal_getut_r (client_connection *connection,
+		  const struct utmp *id, struct utmp *buffer)
+{
+#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_entry (connection->database, connection->position,
+			  buffer) < 0)
+	    {
+	      connection->position = -1;
+	      return -1;
+	    }
+	  connection->position++;
+
+	  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_entry (connection->database, connection->position,
+			  buffer) < 0)
+	    {
+	      connection->position = -1;
+	      return -1;
+	    }
+	  connection->position++;
+
+	  if (proc_utmp_eq (buffer, id))
+	    break;
+	}
+    }
+
+  return 0;
+}