Rewritten.

1 files changed, 322 insertions, 510 deletions

diff --git a/auth/auth.c b/auth/auth.c
index ced121fc..fb20392f 100644
--- a/auth/auth.c
+++ b/auth/auth.c
@@ -1,381 +1,164 @@
-/* Authentication server
-   Copyright (C) 1992, 1993, 1994 Free Software Foundation
+/* Authentication server.
+   Copyright (C) 1996 Free Software Foundation, Inc.
+   Written by Roland McGrath.
 
-This file is part of the GNU Hurd.
+   This file is part of the GNU Hurd.
 
-The GNU Hurd is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+   The GNU Hurd is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
 
-The GNU Hurd 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 General Public License for more details.
+   The GNU Hurd 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
+   General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with the GNU Hurd; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
-/* Written by Michael I. Bushnell.  */
-
-#include "auth_S.h"
-#include "auth_reply_U.h"
-#include "notify_S.h"
-#include <hurd/startup.h>
-#include <mach/error.h>
-#include <errno.h>
-#include <mach/mig_errors.h>
-#include <mach/notify.h>
 #include <stdlib.h>
-#include <hurd.h>
-#include <mach.h>
 #include <string.h>
+#include <mach.h>
+#include <cthreads.h>
+#include <hurd.h>
+#include <hurd/startup.h>
+#include <hurd/ports.h>
+#include <hurd/idvec.h>
+#include <hurd/ihash.h>
+#include <assert.h>
+#include "auth_S.h"
 
-/* This represents a request from a call to auth_user_authenticate
-   which is waiting for the corresponding call.  */
-struct saved_user
-{
-  struct saved_user *next;	/* hash link */
-  
-  mach_port_t rendezvous;	/* rendezvous port */
-  mach_port_t rendezvous2;	/* secondary rendezvous port */
-
-  struct apt *userid;		/* to be passed to server */
-  
-  mach_port_t reply;		/* where to send the answer */
-  mach_msg_type_name_t reply_type; /* type of reply port */
-};
-
-/* This represents a request from a call to auth_server_authenticate
-   which is waiting for the corresponding call.  */
-struct saved_server
-{
-  struct saved_server *next;	/* hash link */
-  
-  mach_port_t rendezvous;	/* rendezvous port */
-  mach_port_t rendezvous2;	/* secondary rendezvous port */
-
-  struct apt *server;		/* who made the call? */
-  mach_port_t passthrough;	/* new port to be given to user */
-
-  mach_port_t reply;		/* where to send the answer */
-  mach_msg_type_name_t reply_type; /* type of reply port */
-};
-
-struct saved_user *userlist;
-struct saved_server *serverlist;
-
-struct apt
-{
-  mach_port_t port;
-  uid_t *gen_uids, *aux_uids;
-  uid_t *gen_gids, *aux_gids;
-  int ngen_uids, naux_uids, ngen_gids, naux_gids;
-  struct apt *next, **prevp;
-};
-
-struct apt *allapts;
-
-struct apt *getauthstruct (void);
-void auth_nosenders (struct apt *);
-
-mach_port_t auth_pset;
-
-/* Our version number */
 char *auth_version = "0.0 pre-alpha";
 
-
-/* Demultiplex an incoming message. */
-int
-request_server (mach_msg_header_t *inp,
-		mach_msg_header_t *outp)
-{
-  extern int auth_server (), notify_server ();
-  
-  return (auth_server (inp, outp) 
-	  || notify_server (inp, outp));
-  
-}
-
-void
-main (int argc, char **argv)
-{
-  mach_port_t boot;
-  struct apt *firstauth;
-  process_t proc;
-  extern int mach_msg_server ();
-  mach_port_t hostpriv, masterdev;
-  
-  mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_PORT_SET,
-		      &auth_pset);
-
-  task_get_bootstrap_port (mach_task_self (), &boot);
-
-  firstauth = getauthstruct ();
-  firstauth->gen_uids = malloc (sizeof (uid_t) * 1);
-  firstauth->aux_uids = malloc (sizeof (uid_t) * 2);
-  firstauth->gen_gids = malloc (sizeof (uid_t) * 1);
-  firstauth->aux_gids = malloc (sizeof (uid_t) * 2);
-  firstauth->gen_uids[0] = 0;
-  firstauth->aux_uids[0] = firstauth->aux_uids[1] = 0;
-  firstauth->gen_gids[0] = 0;
-  firstauth->aux_gids[0] = firstauth->aux_gids[1] = 0;
-  firstauth->ngen_uids = firstauth->ngen_gids = 1;
-  firstauth->naux_uids = firstauth->naux_gids = 2;
-
-  startup_authinit (boot, firstauth->port, MACH_MSG_TYPE_MAKE_SEND, &proc);
-  proc_getprivports (proc, &hostpriv, &masterdev);
-  proc_register_version (proc, hostpriv, "auth", HURD_RELEASE, auth_version);
-  mach_port_deallocate (mach_task_self (), masterdev);
-  _hurd_port_set (&_hurd_ports[INIT_PORT_PROC], proc);
-  _hurd_proc_init (argv);
 
-  /* Init knows intimately that we will be ready for messages
-     as soon as this returns. */
-  startup_essential_task (boot, mach_task_self (), MACH_PORT_NULL, "auth",
-			  hostpriv);
-  mach_port_deallocate (mach_task_self (), boot);
-  mach_port_deallocate (mach_task_self (), hostpriv);
+/* Auth handles are server ports with sets of ids.  */
+struct authhandle
+  {
+    struct port_info pi;
+    struct idvec euids, egids, auids, agids;
+  };
 
-  while (1)
-    mach_msg_server (request_server, vm_page_size * 2, auth_pset);
-}
+struct port_bucket *auth_bucket;
+struct port_class *authhandle_portclass;
 
 
-/* Server routines: */
-
-/* Called when an auth port has no more senders. */
-error_t
-do_mach_notify_no_senders (mach_port_t notify,
-			      mach_port_mscount_t mscount)
-{
-  auth_nosenders (convert_auth_to_apt (notify));
-  return 0;
-}
+/* Create a new auth port.  */
 
-/* A given auth handle has no more senders; deallocate all state referring
-   to this handle.  */
-void
-auth_nosenders (struct apt *auth)
+static error_t
+create_authhandle (struct authhandle **new)
 {
-  /* Remove all references to this from the saved lists */
-  {
-    struct saved_user *s, **prevp, *tmp;
-    for (s = userlist, prevp = &userlist; s;)
-      {
-	if (s->userid == auth)
-	  {
-	    *prevp = s->next;
-	    tmp = s;
-	    prevp = &s->next;
-	    s = s->next;
-	    
-	    mach_port_deallocate (mach_task_self (), tmp->rendezvous);
-	    mach_port_deallocate (mach_task_self (), tmp->reply);
-	    free (tmp);
-	  }
-	else
-	  {
-	    prevp = &s->next;
-	    s = s->next;
-	  }
-      }
-  }
-  {
-    struct saved_server *s, **prevp, *tmp;
-    for (s = serverlist, prevp = &serverlist; s;)
-      {
-	if (s->server == auth)
-	  {
-	    *prevp = s->next;
-	    tmp = s;
-	    prevp = &s->next;
-	    s = s->next;
-	    
-	    mach_port_deallocate (mach_task_self (), tmp->rendezvous);
-	    mach_port_deallocate (mach_task_self (), tmp->reply);
-	    if (tmp->passthrough)
-	      mach_port_deallocate (mach_task_self (), tmp->passthrough);
-	    free (tmp);
-	  }
-	else
-	  {
-	    prevp = &s->next;
-	    s = s->next;
-	  }
-      }
-  }
-
-  /* Take off allapts list */
-  *auth->prevp = auth->next;
-  if (auth->next)
-    auth->next->prevp = auth->prevp;
-
-  /* Delete its storage and port. */
-  mach_port_mod_refs (mach_task_self (), auth->port, 
-		      MACH_PORT_RIGHT_RECEIVE, -1);
-  free (auth->gen_uids);
-  free (auth->aux_uids);
-  free (auth->gen_gids);
-  free (auth->aux_gids);
-  free (auth);
+  error_t err = ports_create_port (authhandle_portclass, auth_bucket,
+				   sizeof **new, new);
+  if (! err)
+    bzero (&(*new)->euids, (void *) &(*new)[1] - (void *) &(*new)->euids);
+  return err;
 }
 
+/* Clean up a dead auth port.  */
 
-/* Return true iff TEST is a genuine or auxiliary group id in AUTH. */
-inline int
-groupmember (gid_t test, 
-	     struct apt *auth)
+static void
+destroy_authhandle (void *p)
 {
-  int i;
-  
-  for (i = 0; i < auth->ngen_gids; i++)
-    if (test == auth->gen_gids[i])
-      return 1;
-  for (i = 0; i < auth->naux_gids; i++)
-    if (test == auth->aux_gids[i])
-      return 1;
-  return 0;
+  struct authhandle *h = p;
+  idvec_free_contents (&h->euids);
+  idvec_free_contents (&h->egids);
+  idvec_free_contents (&h->auids);
+  idvec_free_contents (&h->agids);
 }
 
-/* Return true iff TEST is a genuine or auxiliary uid in AUTH. */
-inline int
-isuid (uid_t test,
-       struct apt *auth)
-{
-  int i;
-  
-  for (i = 0; i < auth->ngen_uids; i++)
-    if (test == auth->gen_uids[i])
-      return 1;
-  for (i = 0; i < auth->naux_uids; i++)
-    if (test == auth->aux_uids[i])
-      return 1;
-  return 0;
-}
+/* Called by server stub functions.  */
 
-/* Return true if the the given auth handle is root (uid 0).  */
-inline int
-isroot (struct apt *idblock)
+authhandle_t
+auth_port_to_handle (auth_t auth)
 {
-  return isuid (0, idblock);
+  return ports_lookup_port (auth_bucket, auth, authhandle_portclass);
 }
+
+/* id management.  */
 
-/* Allocate a new auth handle, complete with port. */
-struct apt *
-getauthstruct ()
+inline void idvec_copyout (struct idvec *idvec, uid_t **ids, uid_t *nids)
 {
-  struct apt *newauth;
-  mach_port_t unused;
-
-  newauth = malloc (sizeof (struct apt));
-  mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE,
-		      &newauth->port);
-  mach_port_request_notification (mach_task_self (), newauth->port,
-				  MACH_NOTIFY_NO_SENDERS, 1, newauth->port,
-				  MACH_MSG_TYPE_MAKE_SEND_ONCE, &unused);
-  mach_port_move_member (mach_task_self (), newauth->port, auth_pset);
-  newauth->next = allapts;
-  if (newauth->next)
-    newauth->next->prevp = &newauth->next;
-  newauth->prevp = &allapts;
-  allapts = newauth;
-  return newauth;
+  if (idvec->num > *nids)
+    *ids = idvec->ids;
+  *nids = idvec->num;
 }
-  
 
-
-/* Client requests */
+#define C(auth, ids)	idvec_copyout (&auth->ids, ids, n##ids)
+#define OUTIDS(auth)	(C (auth, euids), C (auth, egids), \
+			 C (auth, auids), C (auth, agids))
 
 /* Implement auth_getids as described in <hurd/auth.defs>. */
 kern_return_t
-S_auth_getids (struct apt *auth,
-	       uid_t **gen_uids,
-	       u_int *ngen_uids,
-	       uid_t **aux_uids,
-	       u_int *naux_uids,
-	       uid_t **gen_gids,
-	       u_int *ngen_gids,
-	       uid_t **aux_gids,
-	       u_int *naux_gids)
+S_auth_getids (struct authhandle *auth,
+	       uid_t **euids,
+	       u_int *neuids,
+	       uid_t **auids,
+	       u_int *nauids,
+	       uid_t **egids,
+	       u_int *negids,
+	       uid_t **agids,
+	       u_int *nagids)
 {
-  if (!auth)
+  if (! auth)
     return EOPNOTSUPP;
-  
-  if (auth->ngen_uids > *ngen_uids)
-    *gen_uids = auth->gen_uids;
-  else
-    bcopy (auth->gen_uids, *gen_uids, sizeof (uid_t) * auth->ngen_uids);
-  *ngen_uids = auth->ngen_uids;
 
-  if (auth->naux_uids > *naux_uids)
-    *aux_uids = auth->aux_uids;
-  else
-    bcopy (auth->aux_uids, *aux_uids, sizeof (uid_t) * auth->naux_uids);
-  *naux_uids = auth->naux_uids;
-
-  if (auth->ngen_gids > *ngen_gids)
-    *gen_gids = auth->gen_gids;
-  else
-    bcopy (auth->gen_gids, *gen_gids, sizeof (uid_t) * auth->ngen_gids);
-  *ngen_gids = auth->ngen_gids;
-
-  if (auth->naux_gids > *naux_gids)
-    *aux_gids = auth->aux_gids;
-  else
-    bcopy (auth->aux_gids, *aux_gids, sizeof (uid_t) * auth->naux_gids);
-  *naux_gids = auth->naux_gids;
+  OUTIDS (auth);
 
   return 0;
 }
 
 /* Implement auth_makeauth as described in <hurd/auth.defs>. */
 kern_return_t
-S_auth_makeauth (struct apt *auth,
-		 mach_port_t *authpts,
-		 u_int nauths,
-		 uid_t *gen_uids,
-		 u_int ngen_uids,
-		 uid_t *aux_uids,
-		 u_int naux_uids,
-		 uid_t *gen_gids,
-		 u_int ngen_gids,
-		 uid_t *aux_gids,
-		 u_int naux_gids,
+S_auth_makeauth (struct authhandle *auth,
+		 mach_port_t *authpts, u_int nauths,
+		 uid_t *euids, u_int neuids,
+		 uid_t *auids, u_int nauids,
+		 uid_t *egids, u_int negids,
+		 uid_t *agids, u_int nagids,
 		 mach_port_t *newhandle)
 {
-  int i, j;
-  struct apt *newauth;
-  struct apt **auths = alloca ((nauths + 1) * sizeof (struct apt *));
+  struct authhandle *newauth, *auths[1 + nauths];
   int hasroot = 0;
+  error_t err;
+  u_int i, j;
 
   if (!auth)
     return EOPNOTSUPP;
+
   auths[0] = auth;
 
+  /* Verify all the auth ports passed in.  */
   for (i = 0; i < nauths; i++)
-    if (!(auths[i + 1] = convert_auth_to_apt (authpts[i])))
+    if (!(auths[i + 1] = auth_port_to_handle (authpts[i])))
       return EINVAL;
 
-  nauths++;
+  nauths = i;
+
+  /* Verify that the union of the handles passed in either contains euid 0
+     (root), or contains all the requested ids.  */
+
+#define isuid(uid, auth)	idvec_contains (&(auth)->euids, uid)
+#define groupmember(gid, auth)	idvec_contains (&(auth)->egids, gid)
+#define isroot(auth)		isuid (0, auth)
 
   for (i = 0; i < nauths; i++)
-    if (isroot (auth))
+    if (isroot (auths[i]))
       {
 	hasroot = 1;
 	break;
       }
-  
+
   if (!hasroot)
     {
       int has_it;
-      
-      for (i = 0; i < ngen_uids; i++)
+
+      for (i = 0; i < neuids; i++)
 	{
 	  has_it = 0;
 	  for (j = 0; j < nauths; j++)
-	    if (isuid (gen_uids[i], auths[j]))
+	    if (isuid (euids[i], auths[j]))
 	      {
 		has_it = 1;
 		break;
@@ -383,12 +166,12 @@ S_auth_makeauth (struct apt *auth,
 	  if (!has_it)
 	    return EPERM;
 	}
-      
-      for (i = 0; i < naux_uids; i++)
+
+      for (i = 0; i < nauids; i++)
 	{
 	  has_it = 0;
 	  for (j = 0; j < nauths; j++)
-	    if (isuid (aux_uids[i], auths[j]))
+	    if (isuid (auids[i], auths[j]))
 	      {
 		has_it = 1;
 		break;
@@ -396,12 +179,12 @@ S_auth_makeauth (struct apt *auth,
 	  if (!has_it)
 	    return EPERM;
 	}
-      
-      for (i = 0; i < ngen_gids; i++)
+
+      for (i = 0; i < negids; i++)
 	{
 	  has_it = 0;
 	  for (j = 0; j < nauths; j++)
-	    if (groupmember (gen_gids[i], auths[j]))
+	    if (groupmember (egids[i], auths[j]))
 	      {
 		has_it = 1;
 		break;
@@ -409,12 +192,12 @@ S_auth_makeauth (struct apt *auth,
 	  if (!has_it)
 	    return EPERM;
 	}
-	    
-      for (i = 0; i < naux_gids; i++)
+
+      for (i = 0; i < nagids; i++)
 	{
 	  has_it = 0;
 	  for (j = 0; j < nauths; j++)
-	    if (groupmember (aux_gids[i], auths[j]))
+	    if (groupmember (agids[i], auths[j]))
 	      {
 		has_it = 1;
 		break;
@@ -422,232 +205,261 @@ S_auth_makeauth (struct apt *auth,
 	  if (!has_it)
 	    return EPERM;
 	}
-    }  
+    }
 
-  for (j = 0; j < nauths - 1; j++)
+  for (j = 1; j < nauths; ++j)
     mach_port_deallocate (mach_task_self (), authpts[j]);
 
-  newauth = getauthstruct ();
-  newauth->gen_uids = malloc (sizeof (uid_t) * ngen_uids);
-  newauth->aux_uids = malloc (sizeof (uid_t) * naux_uids);
-  newauth->gen_gids = malloc (sizeof (uid_t) * ngen_gids);
-  newauth->aux_gids = malloc (sizeof (uid_t) * naux_gids);
-  newauth->ngen_uids = ngen_uids;
-  newauth->naux_uids = naux_uids;
-  newauth->ngen_gids = ngen_gids;
-  newauth->naux_gids = naux_gids;
-  bcopy (gen_uids, newauth->gen_uids, ngen_uids * sizeof (uid_t));
-  bcopy (aux_uids, newauth->aux_uids, naux_uids * sizeof (uid_t));
-  bcopy (gen_gids, newauth->gen_gids, ngen_gids * sizeof (uid_t));
-  bcopy (aux_gids, newauth->aux_gids, naux_gids * sizeof (uid_t));
-  
-  *newhandle = newauth->port;
-  return 0;
+  err = create_authhandle (&newauth);
+  if (err)
+    return err;
+
+#define MERGE S (euids); S (egids); S (auids); S (agids);
+  if (neuids || nauids || negids || nagids)
+    {
+      /* Create a new handle with the specified ids.  */
+
+#define S(uids) if (!err) err = idvec_merge_ids (&newauth->uids, uids, n##uids)
+      MERGE;
+#undef S
+    }
+  else
+    {
+      /* Use the union of the ids of the passed in handles for the new one.  */
+
+      for (i = 0; !err && i < nauths; ++i)
+	{
+#define S(uids) if (!err) err = idvec_merge (&newauth->uids, &auths[i]->uids)
+	  MERGE;
+#undef S
+	}
+    }
+
+  if (! err)
+    *newhandle = ports_get_right (newauth);
+
+  return err;
+}
+
+/* Transaction handling.  */
+
+/* Table of pending transactions keyed on RENDEZVOUS.  */
+struct ihash *pending_users, *pending_servers;
+struct mutex pending_lock = MUTEX_INITIALIZER;
+
+/* A pending transaction.  */
+struct pending
+  {
+    void **locp;		/* Position in one of the ihash tables.  */
+    struct condition wakeup;    /* The waiter is blocked on this condition.  */
+
+    /* The user's auth handle.  */
+    struct authhandle *user;
+
+    /* The port to pass back to the user.  */
+    mach_port_t passthrough;
+    mach_msg_type_name_t passthrough_type;
+  };
+
+
+/* Request dead-name notification on RENDEZVOUS and arrange that
+   the current thread be cancelled should it die.  */
+static void
+cancel_on_dead_name (struct authhandle *auth, mach_port_t rendezvous)
+{
+  mach_port_t foo;
+  mach_port_request_notification (mach_task_self (), rendezvous,
+				  MACH_NOTIFY_DEAD_NAME, 1,
+				  auth->pi.port_right,
+				  MACH_MSG_TYPE_MAKE_SEND_ONCE, &foo);
+  if (foo != MACH_PORT_NULL)
+    mach_port_deallocate (mach_task_self (), foo);
+  ports_interrupt_self_on_port_death (auth, rendezvous);
 }
 
+
 /* Implement auth_user_authenticate as described in <hurd/auth.defs>. */
 kern_return_t
-S_auth_user_authenticate (struct apt *userauth,
-			  mach_port_t reply,
-			  mach_msg_type_name_t reply_porttype,
+S_auth_user_authenticate (struct authhandle *userauth,
+			  mach_port_t ignored,
 			  mach_port_t rendezvous,
-			  mach_port_t rendezvous2,
 			  mach_port_t *newport,
 			  mach_msg_type_name_t *newporttype)
 {
-  struct saved_server *sv, **spp;
-  struct saved_user *u;
-  
-  if (!userauth)
-    return EOPNOTSUPP;
-  
+  struct pending *s;
+
+  mutex_lock (&pending_lock);
+
   /* Look for this port in the server list.  */
-  for (sv = serverlist, spp = &serverlist; sv;)
+  s = ihash_find (pending_servers, rendezvous);
+  if (s)
+    {
+      /* Found it!  Extract the port.  */
+      *newport = s->passthrough;
+      *newporttype = s->passthrough_type;
+
+      /* Remove it from the pending list.  */
+      ihash_locp_remove (pending_servers, s->locp);
+
+      /* Give the server the auth port and wake the RPC up.  */
+      s->user = userauth;
+      mutex_unlock (&pending_lock);
+      condition_signal (&s->wakeup);
+
+      return 0;
+    }
+  else
     {
-      if (sv->rendezvous == rendezvous && sv->rendezvous2 == rendezvous2)
+      /* No pending server RPC for this port.
+	 Create a pending user RPC record.  */
+      struct pending u;
+      error_t err;
+
+      err = ihash_add (pending_users, rendezvous, &u, &u.locp);
+      if (! err)
 	{
-	  *spp = sv->next;
-	  break;
+	  /* Store the user auth port and wait for the server RPC to wake
+             us up.  */
+	  u.user = userauth;
+	  condition_init (&u.wakeup);
+	  cancel_on_dead_name (userauth, rendezvous);
+	  err = hurd_condition_wait (&u.wakeup, &pending_lock);
 	}
-      else
+      /* The server side has already removed U from the ihash table.  */
+      mutex_unlock (&pending_lock);
+
+      if (! err)
 	{
-	  spp = &sv->next;
-	  sv = sv->next;
+	  /* The server RPC has set the port and signalled U.wakeup.  */
+	  *newport = u.passthrough;
+	  *newporttype = u.passthrough_type;
 	}
+      return err;
     }
-  
-  if (sv)
-    {
-      *newport = sv->passthrough;
-      *newporttype = MACH_MSG_TYPE_MOVE_SEND;
-      auth_server_authenticate_reply (sv->reply, sv->reply_type, 0,
-				      userauth->gen_uids, userauth->ngen_uids,
-				      userauth->aux_uids, userauth->naux_uids,
-				      userauth->gen_gids, userauth->ngen_uids,
-				      userauth->aux_gids, userauth->naux_uids);
-      free (sv);
-      
-      /* Drop both rights from the call.  */
-      mach_port_mod_refs (mach_task_self (), rendezvous, MACH_PORT_RIGHT_SEND,
-			  -2);
-      mach_port_mod_refs (mach_task_self (), rendezvous2, MACH_PORT_RIGHT_SEND,
-			  -2);
-      return 0;
-    }
-
-  /* User got here first.  */
-  u = malloc (sizeof (struct saved_user));
-  
-  u->rendezvous = rendezvous;
-  u->rendezvous2 = rendezvous2;
-  u->userid = userauth;
-
-  u->reply = reply;
-  u->reply_type = reply_porttype;
-  
-  u->next = userlist;
-  userlist = u;
-  
-  return MIG_NO_REPLY;
 }
 
 /* Implement auth_server_authenticate as described in <hurd/auth.defs>. */
 kern_return_t
-S_auth_server_authenticate (struct apt *serverauth,
-			    mach_port_t reply,
-			    mach_msg_type_name_t reply_porttype,
+S_auth_server_authenticate (struct authhandle *serverauth,
+			    mach_port_t ignored,
 			    mach_port_t rendezvous,
-			    mach_port_t rendezvous2,
 			    mach_port_t newport,
-			    uid_t **gen_uids,
-			    u_int *ngen_uids,
-			    uid_t **aux_uids,
-			    u_int *naux_uids,
-			    uid_t **gen_gids,
-			    u_int *ngen_gids,
-			    uid_t **aux_gids,
-			    u_int *naux_gids)
+			    mach_port_t newport_type,
+			    uid_t **euids,
+			    u_int *neuids,
+			    uid_t **auids,
+			    u_int *nauids,
+			    uid_t **egids,
+			    u_int *negids,
+			    uid_t **agids,
+			    u_int *nagids)
 {
-  struct saved_user *su, **sup;
-  struct saved_server *v;
-  struct apt *uauth;
-  
-  if (!serverauth)
-    return EOPNOTSUPP;
+  struct pending *u;
+
+  mutex_lock (&pending_lock);
 
   /* Look for this port in the user list.  */
-  for (su = userlist, sup = &userlist; su;)
+  u = ihash_find (pending_users, rendezvous);
+  if (u)
     {
-      if (su->rendezvous == rendezvous && su->rendezvous2 == rendezvous2)
-	{
-	  *sup = su->next;
-	  break;
-	}
-      else
-	{
-	  sup = &su->next;
-	  su = su->next;
-	}
+      /* Found it!  Extract the ids.  */
+      OUTIDS (u->user);
+
+      /* Remove it from the pending list.  */
+      ihash_locp_remove (pending_users, u->locp);
+
+      /* Give the user the new port and wake the RPC up.  */
+      u->passthrough = newport;
+      u->passthrough_type = newport_type;
+      mutex_unlock (&pending_lock);
+      condition_signal (&u->wakeup);
+
+      return 0;
     }
-  if (su)
+  else
     {
-      auth_user_authenticate_reply (su->reply, su->reply_type, 0, newport,
-				    MACH_MSG_TYPE_MOVE_SEND);
-      
-      uauth = su->userid;
-      
-      if (uauth->ngen_uids > *ngen_uids)
-	*gen_uids = uauth->gen_uids;
-      else
-	bcopy (uauth->gen_uids, *gen_uids, sizeof (uid_t) * uauth->ngen_uids);
-      *ngen_uids = uauth->ngen_uids;
-
-      if (uauth->naux_uids > *naux_uids)
-	*aux_uids = uauth->aux_uids;
-      else
-	bcopy (uauth->aux_uids, *aux_uids, sizeof (uid_t) * uauth->naux_uids);
-      *naux_uids = uauth->naux_uids;
-
-      if (uauth->ngen_gids > *ngen_gids)
-	*gen_gids = uauth->gen_gids;
-      else
-	bcopy (uauth->gen_gids, *gen_gids, sizeof (uid_t) * uauth->ngen_gids);
-      *ngen_gids = uauth->ngen_gids;
-
-      if (uauth->naux_gids > *naux_gids)
-	*aux_gids = uauth->aux_gids;
-      else
-	bcopy (uauth->aux_gids, *aux_gids, sizeof (uid_t) * uauth->naux_gids);
-      *naux_gids = uauth->naux_gids;
-
-      free (su);
-
-      mach_port_mod_refs (mach_task_self (), rendezvous, MACH_PORT_RIGHT_SEND,
-			  -2);
-      mach_port_mod_refs (mach_task_self (), rendezvous2, MACH_PORT_RIGHT_SEND,
-			  -2);
-      return 0;
+      /* No pending user RPC for this port.
+	 Create a pending server RPC record.  */
+      struct pending s;
+      error_t err;
+
+      err = ihash_add (pending_servers, rendezvous, &s, &s.locp);
+      if (! err)
+	{
+	  /* Store the new port and wait for the user RPC to wake us up.  */
+	  s.passthrough = newport;
+	  s.passthrough_type = newport_type;
+	  condition_init (&s.wakeup);
+	  cancel_on_dead_name (serverauth, rendezvous);
+	  err = hurd_condition_wait (&s.wakeup, &pending_lock);
+	}
+      /* The user side has already removed S from the ihash table.  */
+      mutex_unlock (&pending_lock);
+
+      if (! err)
+	/* The user RPC has set the port and signalled S.wakeup.  */
+	OUTIDS (s.user);
+
+      return err;
     }
-  
-  /* Server got here first.  */
-  v = malloc (sizeof (struct saved_server));
-  
-  v->rendezvous = rendezvous;
-  v->rendezvous2 = rendezvous2;
-  v->passthrough = newport;
-  
-  v->reply = reply;
-  v->reply_type = reply_porttype;
-  
-  v->next = serverlist;
-  serverlist = v;
-  
-  return MIG_NO_REPLY;
 }
 
-/* Convert an auth port into an auth handle structure. */
-struct apt *
-convert_auth_to_apt (auth_t auth)
-{
-  struct apt *a;
-  for (a = allapts; a; a = a->next)
-    if (a->port == auth)
-      return a;
-  return 0;
-}
 
-/* Unneeded notification stubs: */
-kern_return_t
-do_mach_notify_port_deleted (mach_port_t notify,
-			     mach_port_t name)
-{
-  return 0;
-}
 
-kern_return_t
-do_mach_notify_msg_accepted (mach_port_t notify,
-			     mach_port_t name)
+static int
+auth_demuxer (mach_msg_header_t *inp, mach_msg_header_t *outp)
 {
-  return 0;
+  extern int auth_server (mach_msg_header_t *inp, mach_msg_header_t *outp);
+  return (auth_server (inp, outp) ||
+	  ports_interrupt_server (inp, outp) ||
+	  ports_notify_server (inp, outp));
 }
 
-kern_return_t
-do_mach_notify_port_destroyed (mach_port_t notify,
-			       mach_port_t name)
-{
-  return 0;
-}
 
-kern_return_t
-do_mach_notify_send_once (mach_port_t notify)
+int
+main (int argc, char **argv)
 {
-  return 0;
-}
+  error_t err;
+  mach_port_t boot;
+  process_t proc;
+  mach_port_t hostpriv, masterdev;
+  struct authhandle *firstauth;
 
-kern_return_t
-do_mach_notify_dead_name (mach_port_t notify,
-			  mach_port_t name)
-{
-  return 0;
-}
+  auth_bucket = ports_create_bucket ();
+  authhandle_portclass = ports_create_class (&destroy_authhandle, 0);
+
+  /* Create the initial root auth handle.  */
+  err = create_authhandle (&firstauth);
+  assert_perror (err);
+  idvec_add (&firstauth->euids, 0);
+  idvec_add (&firstauth->auids, 0);
+  idvec_add (&firstauth->auids, 0);
+  idvec_merge (&firstauth->egids, &firstauth->euids);
+  idvec_merge (&firstauth->agids, &firstauth->auids);
+
+  /* Fetch our bootstrap port and contact the bootstrap filesystem.  */
+  task_get_bootstrap_port (mach_task_self (), &boot);
+  startup_authinit (boot, ports_get_right (firstauth),
+		    MACH_MSG_TYPE_MAKE_SEND, &proc);
+
+  /* Register ourselves with the proc server and then start signals.  */
+  proc_getprivports (proc, &hostpriv, &masterdev);
+  proc_register_version (proc, hostpriv, "auth", HURD_RELEASE, auth_version);
+  mach_port_deallocate (mach_task_self (), masterdev);
+  _hurd_port_set (&_hurd_ports[INIT_PORT_PROC], proc);
+  _hurd_proc_init (argv);
 
+  /* Init knows intimately that we will be ready for messages
+     as soon as this returns. */
+  startup_essential_task (boot, mach_task_self (), MACH_PORT_NULL, "auth",
+			  hostpriv);
+  mach_port_deallocate (mach_task_self (), boot);
+  mach_port_deallocate (mach_task_self (), hostpriv);
+
+  /* Be a server.  */
+  while (1)
+    ports_manage_port_operations_multithread (auth_bucket,
+					      auth_demuxer,
+					      30 * 1000, 0,
+					      0, MACH_PORT_NULL);
+}