initial import

66 files changed, 7738 insertions, 0 deletions

diff --git a/hurd/.cvsignore b/hurd/.cvsignore
new file mode 100644
index 0000000..1f69fd9
--- /dev/null
+++ b/hurd/.cvsignore
@@ -0,0 +1,4 @@
+*.gz *.Z *.tar *.tgz
+=*
+TODO COPYING* AUTHORS copyr-* copying.*
+glibc-*
diff --git a/hurd/Makefile b/hurd/Makefile
new file mode 100644
index 0000000..7a5a1ba
--- /dev/null
+++ b/hurd/Makefile
@@ -0,0 +1,117 @@
+# Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+# This file is part of the GNU C Library.
+
+# 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., 675 Mass Ave,
+# Cambridge, MA 02139, USA.
+
+subdir := hurd
+
+all:
+
+# Some things below (but before including Rules) use configuration variables.
+include ../Makeconfig
+
+
+headers = hurd.h $(interface-headers) \
+	  $(addprefix hurd/,fd.h id.h port.h signal.h userlink.h \
+		            resource.h threadvar.h)
+
+distribute := hurdfault.h intr-rpc.awk intr-rpc.defs STATUS
+
+# The RPC interfaces go in a separate library.
+interface-library := libhurduser.a
+user-interfaces		:= $(addprefix hurd/,\
+				       auth process startup \
+				       msg msg_reply msg_request \
+				       exec core interrupt \
+				       fs fsys io term socket ifsock)
+server-interfaces	:= hurd/msg
+
+routines = hurdinit hurdid hurdlookup hurdpid hurdrlimit hurdprio hurdexec \
+	   setauth \
+	   pid2task task2pid \
+	   getuids setuids getumask fchroot \
+	   hurdsock hurdauth invoke-trans \
+	   privports \
+	   msgportdemux \
+	   fopenport \
+ 	   vpprintf \
+	   ports-get ports-set hurdports hurdmsg \
+	   $(sig) $(dtable) hurdinline
+sig	= hurdsig hurdfault faultexc siginfo hurd-raise preempt-sig \
+	  trampoline longjmp-ts catch-exc exc2signal hurdkill
+dtable	= dtable port2fd new-fd alloc-fd intern-fd \
+	  getdport openport \
+	  fd-close fd-read fd-write hurdioctl ctty-input ctty-output
+
+# XXX this is a temporary hack; see hurdmalloc.h
+routines += hurdmalloc
+distribute += hurdmalloc.h
+
+# Get the proper definition of `hurd-srcdir'.
+include ../sysdeps/mach/hurd/Makefile
+
+# Use and install the Hurd header files directly out of the Hurd source.
+
+# Find the MiG defs files in the Hurd source.
+vpath %.defs $(hurd-srcdir)
+
+# Install all .h and .defs files we find in the Hurd's hurd/ directory.
+hurd-headers := $(patsubst $(hurd-srcdir)/%,%,\
+			   $(wildcard $(addprefix $(hurd-srcdir)/hurd/,\
+						  *.defs *.h)))
+
+
+# Don't distribute the Hurd headers; they are in the Hurd distribution.
+dont_distribute = $(hurd-headers)
+
+# DO NOT try to remake these in any way!!!
+$(addprefix $(hurd-srcdir)/,$(hurd-headers)) : ;
+install-others += $(addprefix $(includedir)/,$(hurd-headers))
+$(includedir)/hurd/%: $(hurd-srcdir)/hurd/%; $(do-install)
+
+include ../mach/Machrules
+include ../Rules
+
+# intr-rpc.defs defines the INTR_INTERFACE macro to make the generated RPC
+# stubs send-interruptible, and to prefix them with `hurd_intr_rpc_'.
+user-MIGFLAGS += -imacros intr-rpc.defs
+
+# Run each generated user stub through intr-rpc.awk, which will detect
+# stubs __hurd_intr_rpc_% and generate the user-callable function for the
+# stub: this is a wrapper which calls __hurd_intr_rpc_% inside
+# HURD_EINTR_RPC.
+define transform-user-stub
+gawk -v call=$${call} -f $(word 2,$^) \
+	$(objpfx)tmp_$${call}.c > $(objpfx)tmpi_$${call}.c; \
+rm -f $(objpfx)tmp_$${call}.c;
+endef
+transform-user-stub-output = tmpi
+
+$(foreach if,$(user-interfaces),$($(if)-calls:%=$(objpfx)RPC_%.o))): \
+	hurd/signal.h
+
+$(user-interfaces:%=$(objpfx)%.ustamp): intr-rpc.awk
+
+$(objpfx)fault%.c $(objpfx)fault%.h: $(mach-srcdir)/mach/%.defs
+	$(MIG) $(MIGFLAGS) -prefix _hurdsig_fault_ \
+	       -server $(@:.h=.c) -sheader $(@:.c=.h) \
+	       -user /dev/null -header /dev/null \
+	       $<
+generated += faultexc.c faultexc.h
+
+# We need this static dependency to get faultexc.h generated the first time.
+$(objpfx)hurdfault.o $(objpfx)hurdfault.d: \
+	$(objpfx)faultexc.h $(objpfx)faultexc.c
diff --git a/hurd/Notes b/hurd/Notes
new file mode 100644
index 0000000..9052f29
--- /dev/null
+++ b/hurd/Notes
@@ -0,0 +1,37 @@
+The library pays attention to some envariables:
+
+CORESERVER     -- Name of core server naming point; falls back to /servers/core
+COREFILE       -- Name of file to write core dump in; falls back to core
+GNUTARGET      -- Passed to core server to specify flavor of core dump format
+
+New functions:
+
+int openport (io_t port);
+FILE *fopenport (mach_port_t, const char *mode);
+file_t getdport (int fd);
+
+task_t pid2task (pid_t);
+pid_t task2pid (task_t);
+
+int fchroot (int fd);
+mode_t getumask (void);
+
+int getuids (int n, uid_t *uidset);
+
+error_t hurd_path_lookup (file_t root, file_t cwd,
+			  const char *path, int flags, mode_t mode,
+			  file_t *port);
+error_t hurd_path_split (file_t root, file_t cwd,
+			 const char *path,
+			 file_t *dir, char **name);
+file_t path_lookup (const char *path, int flags, mode_t mode);
+file_t path_split (const char *path, char **name);
+
+process_t getproc (void);
+int setproc (process_t);
+file_t getcrdir (void);
+int setcrdir (file_t);
+file_t getcwdir (void);
+int setcwdir (file_t);
+auth_t getauth (void);
+int setauth (auth_t);		/* Reauthenticates all library ports.  */
diff --git a/hurd/STATUS b/hurd/STATUS
new file mode 100644
index 0000000..ceb0a86
--- /dev/null
+++ b/hurd/STATUS
@@ -0,0 +1,72 @@
+Status of Hurd support in libc.  Last updated 22 Nov 1994.
+Roland McGrath <roland@gnu.ai.mit.edu>
+
+Everything not noted below is implemented, most of it tested.  There are
+various very small things unfinished or thought to be perhaps wrong
+throughout the code, marked by comments containing `XXX'.
+
+
+* Signals and job control work, but are a very hairy area.
+  There are various ways the signal thread can block and fail
+  to respond when the program is losing badly.
+
+* We are not sure about possible races between setpgrp (A, pgrp) from
+  process B vs process A receiving proc_newids.
+
+* The rest of libc (stdio et al) is not safe for multithreaded programs.
+  mutex locks should be added to various things.
+
+* Recovery from faults in the signal thread is not implemented yet.
+
+* longjmp needs to clean up reply port, intr_port; needs thought about.
+
+* Cooperation with cthreads is not finished.  If you link with cthreads,
+  libc internal code still does not use real condition variables.
+  sigsuspend currently does a busy wait where it should use a condition.
+  Signal state is per kernel thread; for unwired cthreads it should be per
+  cthread instead.
+
+* sigaltstack/sigstack do not really work: the signal stack needs thread
+  variables and cthread data set up, which is not done.
+
+* malloc is a kludge.
+
+* Nothing uses mapped io.  Eventually stdio and read/write/seek should.  I
+  have written a little code for this, but it is far from finished.
+
+* Resource limits do not really work; current implementation is patchy and
+  inconsistent.
+
+* libc implicitly uses some environment variables.  This is a security
+  problem for setuid exec.  Probably crt0 should remove the variables from
+  the environment if setuid.
+
+* The miscellaneous msg.defs calls are only partially implemented.
+
+* The default SIGINFO handler needs to be written.
+
+* File locking is not implemented; the RPC interface is not there yet.
+
+* The current getitimer/setitimer implementation is a kludge.
+
+* mmap cannot do MAP_NOEXTEND.
+
+* Unimplemented calls (from the 4.4 system call list):
+acct
+fstatfs
+getfh
+getfsstat
+getrusage
+madvise
+mincore
+mount
+msync
+profil
+recvmsg
+revoke
+sendmsg
+setpriority
+sstk
+statfs
+swapon
+unmount
diff --git a/hurd/alloc-fd.c b/hurd/alloc-fd.c
new file mode 100644
index 0000000..02a1bdf
--- /dev/null
+++ b/hurd/alloc-fd.c
@@ -0,0 +1,127 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/fd.h>
+#include <hurd/resource.h>
+#include <stdlib.h>
+#include "hurdmalloc.h"		/* XXX */
+
+/* Allocate a new file descriptor and return it, locked.  The new
+   descriptor number will be no less than FIRST_FD.  If the table is full,
+   set errno to EMFILE and return NULL.  If FIRST_FD is negative or bigger
+   than the size of the table, set errno to EINVAL and return NULL.  */
+
+struct hurd_fd *
+_hurd_alloc_fd (int *fd, int first_fd)
+{
+  int i;
+  void *crit;
+  long int rlimit;
+
+  if (first_fd < 0)
+    {
+      errno = EINVAL;
+      return NULL;
+    }
+
+  crit = _hurd_critical_section_lock ();
+
+  __mutex_lock (&_hurd_dtable_lock);
+
+ search:
+  for (i = first_fd; i < _hurd_dtablesize; ++i)
+    {
+      struct hurd_fd *d = _hurd_dtable[i];
+      if (d == NULL)
+	{
+	  /* Allocate a new descriptor structure for this slot,
+	     initializing its port cells to nil.  The test below will catch
+	     and return this descriptor cell after locking it.  */
+	  d = _hurd_new_fd (MACH_PORT_NULL, MACH_PORT_NULL);
+	  if (d == NULL)
+	    {
+	      __mutex_unlock (&_hurd_dtable_lock);
+	      _hurd_critical_section_unlock (crit);
+	      return NULL;
+	    }
+	  _hurd_dtable[i] = d;
+	}
+
+      __spin_lock (&d->port.lock);
+      if (d->port.port == MACH_PORT_NULL)
+	{
+	  __mutex_unlock (&_hurd_dtable_lock);
+	  _hurd_critical_section_unlock (crit);
+	  if (fd != NULL)
+	    *fd = i;
+	  return d;
+	}
+      else
+	__spin_unlock (&d->port.lock);
+    }
+
+  __mutex_lock (&_hurd_rlimit_lock);
+  rlimit = _hurd_rlimits[RLIMIT_OFILE].rlim_cur;
+  __mutex_unlock (&_hurd_rlimit_lock);
+
+  if (first_fd < rlimit)
+    {
+      /* The descriptor table is full.  Check if we have reached the
+	 resource limit, or only the allocated size.  */
+      if (_hurd_dtablesize < rlimit)
+	{
+	  /* Enlarge the table.  */
+	  int save = errno;
+	  struct hurd_fd **new;
+	  /* Try to double the table size (but don't exceed the limit).
+	     If there isn't any at all, give it three slots (because
+	     stdio will take that many anyway).  */
+	  int size = _hurd_dtablesize ? _hurd_dtablesize * 2 : 3;
+	  if (size > rlimit)
+	    size = rlimit;
+	  /* If we fail to allocate that, decrement the desired size
+	     until we succeed in allocating it.  */
+	  do
+	    new = realloc (_hurd_dtable, size * sizeof (*_hurd_dtable));
+	  while (new == NULL && size-- > _hurd_dtablesize);
+	  if (new != NULL)
+	    {
+	      /* We managed to allocate a new table.  Now install it.  */
+	      errno = save;
+	      first_fd = _hurd_dtablesize;
+	      /* Initialize the new slots.  */
+	      for (i = first_fd; i < size; ++i)
+		new[i] = NULL;
+	      _hurd_dtablesize = size;
+	      _hurd_dtable = new;
+	      /* Go back to the loop to initialize the first new slot.  */
+	      goto search;
+	    }
+	}
+      else
+	errno = EMFILE;
+    }
+  else
+    errno = EINVAL;		/* Bogus FIRST_FD value.  */
+
+  __mutex_unlock (&_hurd_dtable_lock);
+  _hurd_critical_section_unlock (crit);
+
+  return NULL;
+}
diff --git a/hurd/catch-exc.c b/hurd/catch-exc.c
new file mode 100644
index 0000000..72e06db
--- /dev/null
+++ b/hurd/catch-exc.c
@@ -0,0 +1,78 @@
+/* Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <mach/exc_server.h>
+#include <hurd/signal.h>
+
+/* Called by the microkernel when a thread gets an exception.  */
+
+kern_return_t
+_S_catch_exception_raise (mach_port_t port,
+			  thread_t thread,
+			  task_t task,
+			  int exception,
+			  int code,
+			  int subcode)
+{
+  int signo, error;
+  long int sigcode;
+  struct hurd_sigstate *ss;
+
+  if (task != __mach_task_self ())
+    /* The sender wasn't the kernel.  */
+    return EPERM;
+
+  /* Call the machine-dependent function to translate the Mach exception
+     codes into a signal number and subcode.  */
+  _hurd_exception2signal (exception, code, subcode,
+			  &signo, &sigcode, &error);
+
+  /* Find the sigstate structure for the faulting thread.  */
+  __mutex_lock (&_hurd_siglock);
+  for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
+    if (ss->thread == thread)
+      break;
+  __mutex_unlock (&_hurd_siglock);
+  if (ss == NULL)
+    ss = _hurd_thread_sigstate (thread); /* Allocate a fresh one.  */
+
+  if (__spin_lock_locked (&ss->lock))
+    {
+      /* Loser.  The thread faulted with its sigstate lock held.  Its
+	 sigstate data is now suspect.  So we reset the parts of it which
+	 could cause trouble for the signal thread.  Anything else
+	 clobbered therein will just hose this user thread, but it's
+	 faulting already.
+
+	 This is almost certainly a library bug: unless random memory
+	 clobberation caused the sigstate lock to gratuitously appear held,
+	 no code should do anything that can fault while holding the
+	 sigstate lock.  */
+
+      ss->critical_section = 0;
+      ss->context = NULL;
+      __spin_unlock (&ss->lock);
+    }
+
+  /* Post the signal.  */
+  _hurd_internal_post_signal (ss, signo, sigcode, error,
+			      MACH_PORT_NULL, MACH_MSG_TYPE_PORT_SEND,
+			      0);
+
+  return KERN_SUCCESS;
+}
diff --git a/hurd/ctty-input.c b/hurd/ctty-input.c
new file mode 100644
index 0000000..71aef1b
--- /dev/null
+++ b/hurd/ctty-input.c
@@ -0,0 +1,77 @@
+/* _hurd_ctty_input -- Do an input RPC and generate SIGTTIN if necessary.
+Copyright (C) 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/signal.h>
+
+/* Call *RPC on PORT and/or CTTY.  If a call on CTTY returns EBACKGROUND,
+   generate SIGTTIN or EIO as appropriate.  */
+
+error_t
+_hurd_ctty_input (io_t port, io_t ctty, error_t (*rpc) (io_t))
+{
+  error_t err;
+
+  do
+    {
+      err = (*rpc) (ctty != MACH_PORT_NULL ? ctty : port);
+      if (ctty != MACH_PORT_NULL && err == EBACKGROUND)
+	{
+	  /* We are a background job and tried to read from the tty.
+	     We should probably get a SIGTTIN signal.  */
+	  struct hurd_sigstate *ss;
+	  if (_hurd_orphaned)
+	    /* Our process group is orphaned.  Don't stop; just fail.  */
+	    err = EIO;
+	  else
+	    {
+	      ss = _hurd_self_sigstate ();
+	      __spin_lock (&ss->lock);
+	      if (__sigismember (&ss->blocked, SIGTTIN) ||
+		  ss->actions[SIGTTIN].sa_handler == SIG_IGN)
+		/* We are blocking or ignoring SIGTTIN.  Just fail.  */
+		err = EIO;
+	      __spin_unlock (&ss->lock);
+	    }
+	  if (err == EBACKGROUND)
+	    {
+	      /* Send a SIGTTIN signal to our process group.
+		 
+		 We must remember here not to clobber ERR, since
+		 the loop condition below uses it to recall that
+		 we should retry after a stop.  */
+
+	      __USEPORT (CTTYID, _hurd_sig_post (0, SIGTTIN, port));
+	      /* XXX what to do if error here? */
+
+	      /* At this point we should have just run the handler for
+		 SIGTTIN or resumed after being stopped.  Now this is
+		 still a "system call", so check to see if we should
+		 restart it.  */
+	      __spin_lock (&ss->lock);
+	      if (!(ss->actions[SIGTTIN].sa_flags & SA_RESTART))
+		err = EINTR;
+	      __spin_unlock (&ss->lock);
+	    }
+	}
+      /* If the last RPC generated a SIGTTIN, loop to try it again.  */
+    } while (err == EBACKGROUND);
+
+  return err;
+}
diff --git a/hurd/ctty-output.c b/hurd/ctty-output.c
new file mode 100644
index 0000000..0d9c543
--- /dev/null
+++ b/hurd/ctty-output.c
@@ -0,0 +1,82 @@
+/* _hurd_ctty_output -- Do an output RPC and generate SIGTTOU if necessary.
+Copyright (C) 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/signal.h>
+
+/* Call *RPC on PORT and/or CTTY.  If a call on CTTY returns EBACKGROUND,
+   generate SIGTTOU if appropriate.  */
+
+error_t
+_hurd_ctty_output (io_t port, io_t ctty, error_t (*rpc) (io_t))
+{
+  error_t err;
+  struct hurd_sigstate *ss;
+  io_t ioport;
+
+  /* Don't use the ctty io port if we are blocking or ignoring SIGTTOU.  */
+  if (ctty == MACH_PORT_NULL)
+    ioport = port;
+  else
+    {
+      ss = _hurd_self_sigstate ();
+      __spin_lock (&ss->lock);
+      if (__sigismember (&ss->blocked, SIGTTOU) ||
+	  ss->actions[SIGTTOU].sa_handler == SIG_IGN)
+	ioport = port;
+      else
+	ioport = ctty;
+      __spin_unlock (&ss->lock);
+    }
+
+  do
+    {
+      err = (*rpc) (ioport);
+      if (ioport == ctty && err == EBACKGROUND)
+	{
+	  if (_hurd_orphaned)
+	    /* Our process group is orphaned, so we never generate a
+	       signal; we just fail.  */
+	    err = EIO;
+	  else
+	    {
+	      /* Send a SIGTTOU signal to our process group.
+		 
+		 We must remember here not to clobber ERR, since
+		 the loop condition below uses it to recall that
+		 we should retry after a stop.  */
+
+	      __USEPORT (CTTYID, _hurd_sig_post (0, SIGTTOU, port));
+	      /* XXX what to do if error here? */
+
+	      /* At this point we should have just run the handler for
+		 SIGTTOU or resumed after being stopped.  Now this is
+		 still a "system call", so check to see if we should
+		 restart it.  */
+	      __spin_lock (&ss->lock);
+	      if (!(ss->actions[SIGTTOU].sa_flags & SA_RESTART))
+		err = EINTR;
+	      __spin_unlock (&ss->lock);
+	    }
+	}
+      /* If the last RPC generated a SIGTTOU, loop to try it again.  */
+    } while (err == EBACKGROUND);
+
+  return err;
+}
diff --git a/hurd/dtable.c b/hurd/dtable.c
new file mode 100644
index 0000000..3e785a9
--- /dev/null
+++ b/hurd/dtable.c
@@ -0,0 +1,277 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <ansidecl.h>
+#include <hurd.h>
+#include <hurd/term.h>
+#include <hurd/fd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <cthreads.h>		/* For `struct mutex'.  */
+#include "set-hooks.h"
+#include "hurdmalloc.h"		/* XXX */
+
+
+struct mutex _hurd_dtable_lock = MUTEX_INITIALIZER; /* XXX ld bug; must init */
+struct hurd_fd **_hurd_dtable;
+int _hurd_dtablesize;
+
+
+DEFINE_HOOK (_hurd_fd_subinit, (void));
+
+/* Initialize the file descriptor table at startup.  */
+
+static void
+init_dtable (void)
+{
+  register size_t i;
+
+  __mutex_init (&_hurd_dtable_lock);
+
+  /* The initial size of the descriptor table is that of the passed-in
+     table.  It will be expanded as necessary up to _hurd_dtable_rlimit.  */
+  _hurd_dtablesize = _hurd_init_dtablesize;
+
+  /* Allocate the vector of pointers.  */
+  _hurd_dtable = malloc (_hurd_dtablesize * sizeof (*_hurd_dtable));
+  if (_hurd_dtablesize != 0 && _hurd_dtable == NULL)
+    __libc_fatal ("hurd: Can't allocate file descriptor table\n");
+
+  /* Initialize the descriptor table.  */
+  for (i = 0; i < _hurd_init_dtablesize; ++i)
+    {
+      if (_hurd_init_dtable[i] == MACH_PORT_NULL)
+	/* An unused descriptor is marked by a null pointer.  */
+	_hurd_dtable[i] = NULL;
+      else
+	{
+	  /* Allocate a new file descriptor structure.  */
+	  struct hurd_fd *new = malloc (sizeof (struct hurd_fd));
+	  if (new == NULL)
+	    __libc_fatal ("hurd: Can't allocate initial file descriptors\n");
+
+	  /* Initialize the port cells.  */
+	  _hurd_port_init (&new->port, MACH_PORT_NULL);
+	  _hurd_port_init (&new->ctty, MACH_PORT_NULL);
+
+	  /* Install the port in the descriptor.
+	     This sets up all the ctty magic.  */
+	  _hurd_port2fd (new, _hurd_init_dtable[i], 0);
+
+	  _hurd_dtable[i] = new;
+	}
+    }
+
+  /* Clear out the initial descriptor table.
+     Everything must use _hurd_dtable now.  */
+  __vm_deallocate (__mach_task_self (),
+		   (vm_address_t) _hurd_init_dtable,
+		   _hurd_init_dtablesize * sizeof (_hurd_init_dtable[0]));
+  _hurd_init_dtable = NULL;
+  _hurd_init_dtablesize = 0;
+
+  /* Initialize the remaining empty slots in the table.  */
+  for (; i < _hurd_dtablesize; ++i)
+    _hurd_dtable[i] = NULL;
+
+  /* Run things that want to run after the file descriptor table
+     is initialized.  */
+  RUN_HOOK (_hurd_fd_subinit, ());
+
+  (void) &init_dtable;		/* Avoid "defined but not used" warning.  */
+}
+
+text_set_element (_hurd_subinit, init_dtable);
+
+/* XXX when the linker supports it, the following functions should all be
+   elsewhere and just have text_set_elements here.  */
+
+/* Called by `getdport' to do its work.  */
+
+static file_t
+get_dtable_port (int fd)
+{
+  file_t dport;
+  int err = HURD_DPORT_USE (fd, __mach_port_mod_refs (__mach_task_self (),
+						      (dport = port),
+						      MACH_PORT_RIGHT_SEND,
+						      1));
+  if (err)
+    {
+      errno = err;
+      return MACH_PORT_NULL;
+    }
+  else
+    return dport;
+}
+
+file_t (*_hurd_getdport_fn) (int fd) = get_dtable_port;
+
+#include <hurd/signal.h>
+
+/* We are in the child fork; the dtable lock is still held.
+   The parent has inserted send rights for all the normal io ports,
+   but we must recover ctty-special ports for ourselves.  */
+static error_t
+fork_child_dtable (void)
+{
+  error_t err;
+  int i;
+
+  err = 0;
+
+  for (i = 0; !err && i < _hurd_dtablesize; ++i)
+    {
+      struct hurd_fd *d = _hurd_dtable[i];
+      if (d == NULL)
+	continue;
+
+      /* No other thread is using the send rights in the child task.  */
+      d->port.users = d->ctty.users = NULL;
+
+      if (d->ctty.port != MACH_PORT_NULL)
+	{
+	  /* There was a ctty-special port in the parent.
+	     We need to get one for ourselves too.  */
+	  __mach_port_deallocate (__mach_task_self (), d->ctty.port);
+	  err = __term_open_ctty (d->port.port, _hurd_pid, _hurd_pgrp,
+				  &d->ctty.port);
+	  if (err)
+	    d->ctty.port = MACH_PORT_NULL;
+	}
+
+      /* XXX for each fd with a cntlmap, reauth and re-map_cntl.  */
+    }
+  return err;
+
+  (void) &fork_child_dtable;	/* Avoid "defined but not used" warning.  */
+}
+
+data_set_element (_hurd_fork_locks, _hurd_dtable_lock);	/* XXX ld bug: bss */
+text_set_element (_hurd_fork_child_hook, fork_child_dtable);
+
+/* Called when our process group has changed.  */
+
+static void
+ctty_new_pgrp (void)
+{
+  int i;
+  
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&_hurd_dtable_lock);
+
+  for (i = 0; i < _hurd_dtablesize; ++i)
+    {
+      struct hurd_fd *const d = _hurd_dtable[i];
+      struct hurd_userlink ulink, ctty_ulink;
+      io_t port, ctty;
+
+      if (d == NULL)
+	/* Nothing to do for an unused descriptor cell.  */
+	continue;
+
+      port = _hurd_port_get (&d->port, &ulink);
+      ctty = _hurd_port_get (&d->ctty, &ctty_ulink);
+
+      if (ctty != MACH_PORT_NULL)
+	{
+	  /* This fd has a ctty-special port.  We need a new one, to tell
+             the io server of our different process group.  */
+	  io_t new;
+	  if (__term_open_ctty (port, _hurd_pid, _hurd_pgrp, &new))
+	    new = MACH_PORT_NULL;
+	  _hurd_port_set (&d->ctty, new);
+	}
+
+      _hurd_port_free (&d->port, &ulink, port);
+      _hurd_port_free (&d->ctty, &ctty_ulink, ctty);
+    }
+
+  __mutex_unlock (&_hurd_dtable_lock);
+  HURD_CRITICAL_END;
+
+  (void) &ctty_new_pgrp;	/* Avoid "defined but not used" warning.  */
+}
+
+text_set_element (_hurd_pgrp_changed_hook, ctty_new_pgrp);
+
+/* Called to reauthenticate the dtable when the auth port changes.  */
+
+static void
+reauth_dtable (void)
+{
+  int i;
+
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&_hurd_dtable_lock);
+
+  for (i = 0; i < _hurd_dtablesize; ++i)
+    {
+      struct hurd_fd *const d = _hurd_dtable[i];
+      mach_port_t new, newctty, ref;
+      
+      if (d == NULL)
+	/* Nothing to do for an unused descriptor cell.  */
+	continue;
+
+      ref = __mach_reply_port ();
+
+      /* Take the descriptor cell's lock.  */
+      __spin_lock (&d->port.lock);
+      
+      /* Reauthenticate the descriptor's port.  */
+      if (d->port.port != MACH_PORT_NULL &&
+	  ! __io_reauthenticate (d->port.port,
+				 ref, MACH_MSG_TYPE_MAKE_SEND) &&
+	  ! __USEPORT (AUTH, __auth_user_authenticate
+		       (port,
+			d->port.port,
+			ref, MACH_MSG_TYPE_MAKE_SEND,
+			&new)))
+	{
+	  /* Replace the port in the descriptor cell
+	     with the newly reauthenticated port.  */
+
+	  if (d->ctty.port != MACH_PORT_NULL &&
+	      ! __io_reauthenticate (d->ctty.port,
+				     ref, MACH_MSG_TYPE_MAKE_SEND) &&
+	      ! __USEPORT (AUTH, __auth_user_authenticate
+			   (port,
+			    d->ctty.port,
+			    ref, MACH_MSG_TYPE_MAKE_SEND,
+			    &newctty)))
+	    _hurd_port_set (&d->ctty, newctty);
+
+	  _hurd_port_locked_set (&d->port, new);
+	}
+      else
+	/* Lost.  Leave this descriptor cell alone.  */
+	__spin_unlock (&d->port.lock);
+
+      __mach_port_destroy (__mach_task_self (), ref);
+    }
+
+  __mutex_unlock (&_hurd_dtable_lock);
+  HURD_CRITICAL_END;
+
+  (void) &reauth_dtable;	/* Avoid "defined but not used" warning.  */
+}
+
+text_set_element (_hurd_reauth_hook, reauth_dtable);
diff --git a/hurd/fchroot.c b/hurd/fchroot.c
new file mode 100644
index 0000000..cccf139
--- /dev/null
+++ b/hurd/fchroot.c
@@ -0,0 +1,43 @@
+/* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <ansidecl.h>
+#include <unistd.h>
+#include <hurd.h>
+#include <hurd/fd.h>
+
+/* Change the current root directory to FD.  */
+int
+DEFUN(fchroot, (fd), int fd)
+{
+  error_t err;
+  file_t dir;
+
+  err = __USEPORT (CRDIR,
+		   ({ file_t crdir = port;
+		      HURD_DPORT_USE (fd,
+				      __hurd_file_name_lookup (crdir, port, "",
+							       0, 0, &dir));
+		    }));
+
+  if (err)
+    return __hurd_fail (err);
+
+  _hurd_port_set (&_hurd_ports[INIT_PORT_CRDIR], dir);
+  return 0;
+}
diff --git a/hurd/fd-close.c b/hurd/fd-close.c
new file mode 100644
index 0000000..54beb2a
--- /dev/null
+++ b/hurd/fd-close.c
@@ -0,0 +1,46 @@
+/* Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd/fd.h>
+
+error_t
+_hurd_fd_close (struct hurd_fd *fd)
+{
+  error_t err;
+
+  HURD_CRITICAL_BEGIN;
+
+  __spin_lock (&fd->port.lock);
+  if (fd->port.port == MACH_PORT_NULL)
+    {
+      __spin_unlock (&fd->port.lock);
+      err = EBADF;
+    }
+  else
+    {
+      /* Clear the descriptor's port cells.
+	 This deallocates the ports if noone else is still using them.  */
+      _hurd_port_set (&fd->ctty, MACH_PORT_NULL);
+      _hurd_port_locked_set (&fd->port, MACH_PORT_NULL);
+      err = 0;
+    }
+
+  HURD_CRITICAL_END;
+
+  return err;
+}
diff --git a/hurd/fd-read.c b/hurd/fd-read.c
new file mode 100644
index 0000000..842066c
--- /dev/null
+++ b/hurd/fd-read.c
@@ -0,0 +1,49 @@
+/* Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <errno.h>
+#include <unistd.h>
+#include <hurd.h>
+#include <hurd/fd.h>
+#include <string.h>
+
+error_t
+_hurd_fd_read (struct hurd_fd *fd, void *buf, size_t *nbytes)
+{
+  error_t err;
+  char *data;
+  mach_msg_type_number_t nread;
+
+  error_t readfd (io_t port)
+    {
+      return __io_read (port, &data, &nread, -1, *nbytes);
+    }
+
+  data = buf;
+  if (err = HURD_FD_PORT_USE (fd, _hurd_ctty_input (port, ctty, readfd)))
+    return err;
+
+  if (data != buf)
+    {
+      memcpy (buf, data, nread);
+      __vm_deallocate (__mach_task_self (), (vm_address_t) data, nread);
+    }
+
+  *nbytes = nread;
+  return 0;
+}
diff --git a/hurd/fd-write.c b/hurd/fd-write.c
new file mode 100644
index 0000000..f228d5e
--- /dev/null
+++ b/hurd/fd-write.c
@@ -0,0 +1,42 @@
+/* _hurd_fd_write -- write to a file descriptor; handles job control et al.
+Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <errno.h>
+#include <unistd.h>
+#include <hurd.h>
+#include <hurd/fd.h>
+
+error_t
+_hurd_fd_write (struct hurd_fd *fd, const void *buf, size_t *nbytes)
+{
+  error_t err;
+  mach_msg_type_number_t wrote;
+
+  error_t writefd (io_t port)
+    {
+      return __io_write (port, buf, *nbytes, -1, &wrote);
+    }
+
+  err = HURD_FD_PORT_USE (fd, _hurd_ctty_output (port, ctty, writefd));
+
+  if (! err)
+    *nbytes = wrote;
+
+  return err;
+}
diff --git a/hurd/fopenport.c b/hurd/fopenport.c
new file mode 100644
index 0000000..5792b3e
--- /dev/null
+++ b/hurd/fopenport.c
@@ -0,0 +1,131 @@
+/* Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <ansidecl.h>
+#include <hurd.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+
+/* Read up to N chars into BUF from COOKIE.
+   Return how many chars were read, 0 for EOF or -1 for error.  */
+static ssize_t
+readio (void *cookie, char *buf, size_t n)
+{
+  mach_msg_type_number_t nread;
+  error_t err;
+  char *bufp = buf;
+
+  nread = n;
+  if (err = __io_read ((io_t) cookie, &bufp, &nread, -1, n))
+    return __hurd_fail (err);
+
+  if (bufp != buf)
+    {
+      memcpy (buf, bufp, nread);
+      __vm_deallocate (__mach_task_self (),
+		       (vm_address_t) bufp, (vm_size_t) nread);
+    }
+
+  return nread;
+}
+
+/* Write up to N chars from BUF to COOKIE.
+   Return how many chars were written or -1 for error.  */
+static ssize_t
+writeio (void *cookie, const char *buf, size_t n)
+{
+  mach_msg_type_number_t wrote;
+  error_t err;
+
+  if (err = __io_write ((io_t) cookie, buf, n, -1, &wrote))
+    return __hurd_fail (err);
+
+  return wrote;
+}
+
+/* Move COOKIE's file position *POS bytes, according to WHENCE.
+   The current file position is stored in *POS.
+   Returns zero if successful, nonzero if not.  */
+static int
+seekio (void *cookie, fpos_t *pos, int whence)
+{
+  error_t error = __io_seek ((file_t) cookie, *pos, whence, pos);
+  if (error)
+    return __hurd_fail (error);
+  return 0;
+}
+
+/* Close the file associated with COOKIE.
+   Return 0 for success or -1 for failure.  */
+static int
+closeio (void *cookie)
+{
+  error_t error = __mach_port_deallocate (__mach_task_self (),
+					  (mach_port_t) cookie);
+  if (error)
+    return __hurd_fail (error);
+  return 0;
+}
+
+static const __io_functions funcsio = { readio, writeio, seekio, closeio };
+
+
+/* Defined in fopen.c.  */
+extern int EXFUN(__getmode, (CONST char *mode, __io_mode *mptr));
+
+
+/* Open a stream on PORT.  MODE is as for fopen.  */
+
+FILE *
+__fopenport (mach_port_t port, const char *mode)
+{
+  register FILE *stream;
+  __io_mode m;
+  int pflags;
+  error_t err;
+
+  if (!__getmode (mode, &m))
+    return NULL;
+
+  /* Verify the PORT is valid allows the access MODE specifies.  */
+
+  if (err = __io_get_openmodes (port, &pflags))
+    return __hurd_fail (err), NULL;
+
+  /* Check the access mode.  */
+  if ((m.__read && !(pflags & O_READ)) || (m.__write && !(pflags & O_WRITE)))
+    {
+      errno = EBADF;
+      return NULL;
+    }
+
+  stream = __newstream ();
+  if (stream == NULL)
+    return NULL;
+
+  stream->__cookie = (PTR) port;
+  stream->__mode = m;
+  stream->__io_funcs = funcsio;
+  stream->__room_funcs = __default_room_functions;
+  stream->__seen = 1;
+
+  return stream;
+}
+
+weak_alias (__fopenport, fopenport)
diff --git a/hurd/getdport.c b/hurd/getdport.c
new file mode 100644
index 0000000..884deaa
--- /dev/null
+++ b/hurd/getdport.c
@@ -0,0 +1,54 @@
+/* Copyright (C) 1991, 1992, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+/* This is initialized in dtable.c when that gets linked in.
+   If dtable.c is not linked in, it will be zero.  */
+file_t (*_hurd_getdport_fn) (int fd);
+
+file_t
+__getdport (int fd)
+{
+  if (_hurd_getdport_fn)
+    /* dtable.c has defined the function to fetch a port from the real file
+       descriptor table.  */
+    return (*_hurd_getdport_fn) (fd);
+
+  /* getdport is the only use of file descriptors,
+     so we don't bother allocating a real table.  */
+
+  if (_hurd_init_dtable == NULL)
+    /* Never had a descriptor table.  */
+    return EBADF;
+
+  if (fd < 0 || fd > _hurd_init_dtablesize ||
+      _hurd_init_dtable[fd] == MACH_PORT_NULL)
+    {
+      errno = EBADF;
+      return MACH_PORT_NULL;
+    }
+  else      
+    {
+      __mach_port_mod_refs (__mach_task_self (), _hurd_init_dtable[fd],
+			    MACH_PORT_RIGHT_SEND, 1);
+      return _hurd_init_dtable[fd];
+    }
+}
+
+weak_alias (__getdport, getdport)
diff --git a/hurd/getuids.c b/hurd/getuids.c
new file mode 100644
index 0000000..9a62f65
--- /dev/null
+++ b/hurd/getuids.c
@@ -0,0 +1,63 @@
+/* Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/id.h>
+#include <string.h>
+
+int
+__getuids (int n, uid_t *uidset)
+{
+  error_t err;
+  int nuids;
+  void *crit;
+
+  crit = _hurd_critical_section_lock ();
+  __mutex_lock (&_hurd_id.lock);
+
+  if (err = _hurd_check_ids ())
+    {
+      __mutex_unlock (&_hurd_id.lock);
+      _hurd_critical_section_unlock (crit);
+      return __hurd_fail (err);
+    }
+
+  nuids = _hurd_id.gen.nuids;
+
+  if (n != 0)
+    {
+      /* Copy the uids onto stack storage and then release the idlock.  */
+      uid_t uids[nuids];
+      memcpy (uids, _hurd_id.gen.uids, sizeof (uids));
+      __mutex_unlock (&_hurd_id.lock);
+      _hurd_critical_section_unlock (crit);
+
+      /* Now that the lock is released, we can safely copy the
+	 uid set into the user's array, which might fault.  */
+      if (nuids > n)
+	nuids = n;
+      memcpy (uidset, uids, nuids * sizeof (uid_t));
+    }
+  else
+    {
+      __mutex_unlock (&_hurd_id.lock);
+      _hurd_critical_section_unlock (crit);
+    }
+
+  return nuids;
+}
diff --git a/hurd/getumask.c b/hurd/getumask.c
new file mode 100644
index 0000000..80a8bf4
--- /dev/null
+++ b/hurd/getumask.c
@@ -0,0 +1,25 @@
+/* Copyright (C) 1992 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+mode_t
+getumask (void)
+{
+  return _hurd_umask;
+}
diff --git a/hurd/hurd-raise.c b/hurd/hurd-raise.c
new file mode 100644
index 0000000..ad01ab9
--- /dev/null
+++ b/hurd/hurd-raise.c
@@ -0,0 +1,48 @@
+/* Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/signal.h>
+#include <hurd/msg.h>
+#include <setjmp.h>
+
+/* Handle signal SIGNO in the calling thread.
+   If SS is not NULL it is the sigstate for the calling thread;
+   SS->lock is held on entry and released before return.  */
+
+void
+_hurd_raise_signal (struct hurd_sigstate *ss,
+		    int signo, long int sigcode, int sigerror)
+{
+  if (ss == NULL)
+    {
+      ss = _hurd_self_sigstate ();
+      __spin_lock (&ss->lock);
+    }
+
+  /* Mark SIGNO as pending to be delivered.  */
+  __sigaddset (&ss->pending, signo);
+  ss->pending_data[signo].code = sigcode;
+  ss->pending_data[signo].error = sigerror;
+
+  __spin_unlock (&ss->lock);
+
+  /* Send a message to the signal thread so it
+     will wake up and check for pending signals.  */
+  __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+}
diff --git a/hurd/hurd.h b/hurd/hurd.h
new file mode 100644
index 0000000..472fb91
--- /dev/null
+++ b/hurd/hurd.h
@@ -0,0 +1,292 @@
+/* Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_H
+
+#define	_HURD_H	1
+#include <features.h>
+
+
+/* Get types, macros, constants and function declarations
+   for all Mach microkernel interaction.  */
+#include <mach.h>
+#include <mach/mig_errors.h>
+
+/* Get types and constants necessary for Hurd interfaces.  */
+#include <hurd/hurd_types.h>
+
+/* Get MiG stub declarations for commonly used Hurd interfaces.  */
+#include <hurd/auth.h>
+#include <hurd/process.h>
+#include <hurd/fs.h>
+#include <hurd/io.h>
+
+/* Get `struct hurd_port' and related definitions implementing lightweight
+   user references for ports.  These are used pervasively throughout the C
+   library; this is here to avoid putting it in nearly every source file.  */
+#include <hurd/port.h>
+
+#include <errno.h>
+#define	__hurd_fail(err)	(errno = (err), -1)
+
+/* Basic ports and info, initialized by startup.  */
+
+extern int _hurd_exec_flags;	/* Flags word passed in exec_startup.  */
+extern struct hurd_port *_hurd_ports;
+extern unsigned int _hurd_nports;
+extern volatile mode_t _hurd_umask;
+
+/* Shorthand macro for referencing _hurd_ports (see <hurd/port.h>).  */
+
+#define	__USEPORT(which, expr) \
+  HURD_PORT_USE (&_hurd_ports[INIT_PORT_##which], (expr))
+
+
+/* Base address and size of the initial stack set up by the exec server.
+   If using cthreads, this stack is deallocated in startup.
+   Not locked.  */
+
+extern vm_address_t _hurd_stack_base;
+extern vm_size_t _hurd_stack_size;
+
+/* Initial file descriptor table we were passed at startup.  If we are
+   using a real dtable, these are turned into that and then cleared at
+   startup.  If not, these are never changed after startup.  Not locked.  */
+
+extern mach_port_t *_hurd_init_dtable;
+extern mach_msg_type_number_t _hurd_init_dtablesize;
+
+/* Current process IDs.  */
+
+extern pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp;
+extern int _hurd_orphaned;
+
+/* This variable is incremented every time the process IDs change.  */
+
+unsigned int _hurd_pids_changed_stamp;
+
+/* This condition is broadcast every time the process IDs change.  */
+struct condition _hurd_pids_changed_sync;
+
+/* Unix `data break', for brk and sbrk.
+   If brk and sbrk are not used, this info will not be initialized or used.  */
+
+
+/* Data break.  This is what `sbrk (0)' returns.  */
+
+extern vm_address_t _hurd_brk;
+
+/* End of allocated space.  This is generally `round_page (_hurd_brk)'.  */
+
+extern vm_address_t _hurd_data_end;
+
+/* This mutex locks _hurd_brk and _hurd_data_end.  */
+
+extern struct mutex _hurd_brk_lock;
+
+/* Set the data break to NEWBRK; _hurd_brk_lock must
+   be held, and is released on return.  */
+
+extern int _hurd_set_brk (vm_address_t newbrk);
+
+#define __need_FILE
+#include <stdio.h>
+
+/* Calls to get and set basic ports.  */
+
+extern error_t _hurd_ports_get (int which, mach_port_t *result);
+extern error_t _hurd_ports_set (int which, mach_port_t newport);
+
+extern process_t getproc (void);
+extern file_t getcwdir (void), getcrdir (void);
+extern auth_t getauth (void);
+extern mach_port_t getcttyid ();
+extern int setproc (process_t);
+extern int setcwdir (file_t), setcrdir (file_t);
+extern int setcttyid (mach_port_t);
+
+/* Does reauth with the proc server and fd io servers.  */
+extern int __setauth (auth_t), setauth (auth_t);
+
+
+/* Split FILE into a directory and a name within the directory.  Look up a
+   port for the directory and store it in *DIR; store in *NAME a pointer
+   into FILE where the name within directory begins.  The directory lookup
+   uses CRDIR for the root directory and CWDIR for the current directory.
+   Returns zero on success or an error code.  */
+
+extern error_t __hurd_file_name_split (file_t crdir, file_t cwdir,
+				       const char *file,
+				       file_t *dir, char **name);
+extern error_t hurd_file_name_split (file_t crdir, file_t cwdir,
+				     const char *file,
+				     file_t *dir, char **name);
+
+/* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
+   The file lookup uses CRDIR for the root directory and CWDIR for the
+   current directory.  If successful, returns zero and store the port
+   to FILE in *PORT; otherwise returns an error code. */
+
+extern error_t __hurd_file_name_lookup (file_t crdir, file_t cwdir,
+					const char *file,
+					int flags, mode_t mode,
+					file_t *port);
+extern error_t hurd_file_name_lookup (file_t crdir, file_t cwdir,
+				      const char *filename,
+				      int flags, mode_t mode,
+				      file_t *port);
+
+/* Process the values returned by `dir_lookup' et al, and loop doing
+   `dir_lookup' calls until one returns FS_RETRY_NONE.  CRDIR is the
+   root directory used for things like symlinks to absolute file names; the
+   other arguments should be those just passed to and/or returned from
+   `dir_lookup', `fsys_getroot', or `file_invoke_translator'.  This
+   function consumes the reference in *RESULT even if it returns an error.  */
+
+extern error_t __hurd_file_name_lookup_retry (file_t crdir,
+					      enum retry_type doretry,
+					      char retryname[1024],
+					      int flags, mode_t mode,
+					      file_t *result);
+extern error_t hurd_file_name_lookup_retry (file_t crdir,
+					    enum retry_type doretry,
+					    char retryname[1024],
+					    int flags, mode_t mode,
+					    file_t *result);
+
+
+/* Split FILE into a directory and a name within the directory.  The
+   directory lookup uses the current root and working directory.  If
+   successful, stores in *NAME a pointer into FILE where the name
+   within directory begins and returns a port to the directory;
+   otherwise sets `errno' and returns MACH_PORT_NULL.  */
+
+extern file_t __file_name_split (const char *file, char **name);
+extern file_t file_name_split (const char *file, char **name);
+
+/* Open a port to FILE with the given FLAGS and MODE (see <fcntl.h>).
+   The file lookup uses the current root and working directory.
+   Returns a port to the file if successful; otherwise sets `errno'
+   and returns MACH_PORT_NULL.  */
+
+extern file_t __file_name_lookup (const char *file, int flags, mode_t mode);
+extern file_t file_name_lookup (const char *file, int flags, mode_t mode);
+
+/* Invoke any translator set on the node FILE represents, and return in
+   *TRANSLATED a port to the translated node.  FLAGS are as for
+   `dir_lookup' et al, but the returned port will not necessarily have
+   any more access rights than FILE does.  */
+
+extern error_t __hurd_invoke_translator (file_t file, int flags,
+					 file_t *translated);
+extern error_t hurd_invoke_translator (file_t file, int flags,
+				       file_t *translated);
+
+
+/* Open a file descriptor on a port.  FLAGS are as for `open'; flags
+   affected by io_set_openmodes are not changed by this.  If successful,
+   this consumes a user reference for PORT (which will be deallocated on
+   close).  */
+
+extern int openport (io_t port, int flags);
+
+/* Open a stream on a port.  MODE is as for `fopen'.
+   If successful, this consumes a user reference for PORT
+   (which will be deallocated on fclose).  */
+
+extern FILE *fopenport (io_t port, const char *mode);
+extern FILE *__fopenport (io_t port, const char *mode);
+
+
+/* Execute a file, replacing TASK's current program image.  */
+
+extern error_t _hurd_exec (task_t task,
+			   file_t file,
+			   char *const argv[],
+			   char *const envp[]);
+
+
+/* Inform the proc server we have exitted with STATUS, and kill the
+   task thoroughly.  This function never returns, no matter what.  */
+
+extern void _hurd_exit (int status) __attribute__ ((noreturn));
+
+
+/* Initialize the library data structures from the
+   ints and ports passed to us by the exec server.
+   Then vm_deallocate PORTARRAY and INTARRAY.  */
+
+extern void _hurd_init (int flags, char **argv,
+			mach_port_t *portarray, size_t portarraysize,
+			int *intarray, size_t intarraysize);
+
+/* Do startup handshaking with the proc server.  */
+
+extern void _hurd_proc_init (char **argv);
+
+
+/* Return the socket server for sockaddr domain DOMAIN.  If DEAD is
+   nonzero, remove the old cached port and always do a fresh lookup.
+
+   It is assumed that a socket server will stay alive during a complex socket
+   operation involving several RPCs.  But a socket server may die during
+   long idle periods between socket operations.  Callers should first pass
+   zero for DEAD; if the first socket RPC tried on the returned port fails
+   with MACH_SEND_INVALID_DEST or MIG_SERVER_DIED (indicating the server
+   went away), the caller should call _hurd_socket_server again with DEAD
+   nonzero and retry the RPC on the new socket server port.  */
+
+extern socket_t _hurd_socket_server (int domain, int dead);
+
+/* Send a `sig_post' RPC to process number PID.  If PID is zero,
+   send the message to all processes in the current process's process group.
+   If PID is < -1, send SIG to all processes in process group - PID.
+   SIG and REFPORT are passed along in the request message.  */
+
+extern error_t _hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
+extern error_t hurd_sig_post (pid_t pid, int sig, mach_port_t refport);
+
+/* Fetch the host privileged port and device master port from the proc
+   server.  They are fetched only once and then cached in the
+   variables below.  A special program that gets them from somewhere
+   other than the proc server (such as a bootstrap filesystem) can set
+   these variables to install the ports.  */
+
+extern kern_return_t get_privileged_ports (host_priv_t *host_priv_ptr,
+					   device_t *device_master_ptr);
+extern mach_port_t _hurd_host_priv, _hurd_device_master;
+
+/* Return the PID of the task whose control port is TASK.
+   On error, sets `errno' and returns -1.  */
+
+extern pid_t __task2pid (task_t task), task2pid (task_t task);
+
+/* Return the task control port of process PID.
+   On error, sets `errno' and returns MACH_PORT_NULL.  */
+
+extern task_t __pid2task (pid_t pid), pid2task (pid_t pid);
+
+
+/* Return the io server port for file descriptor FD.
+   This adds a Mach user reference to the returned port.
+   On error, sets `errno' and returns MACH_PORT_NULL.  */
+
+extern io_t __getdport (int fd), getdport (int fd);
+
+
+#endif	/* hurd.h */
diff --git a/hurd/hurd/fd.h b/hurd/hurd/fd.h
new file mode 100644
index 0000000..4747c78
--- /dev/null
+++ b/hurd/hurd/fd.h
@@ -0,0 +1,222 @@
+/* File descriptors.
+Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_FD_H
+
+#define	_HURD_FD_H	1
+#include <features.h>
+
+#include <hurd/hurd_types.h>
+#include <hurd/port.h>
+
+
+/* Structure representing a file descriptor.  */
+
+struct hurd_fd
+  {
+    struct hurd_port port;	/* io server port.  */
+    int flags;			/* fcntl flags; locked by port.lock.  */
+
+    /* Normal port to the ctty.  When `port' is our ctty, this is a port to
+       the same io object but which never returns EBACKGROUND; when not,
+       this is nil.  */
+    struct hurd_port ctty;
+  };
+
+
+/* Current file descriptor table.  */
+
+extern int _hurd_dtablesize;
+extern struct hurd_fd **_hurd_dtable;
+extern struct mutex _hurd_dtable_lock; /* Locks those two variables.  */
+
+#include <hurd/signal.h>
+#include <lock-intern.h>
+
+#ifndef _EXTERN_INLINE
+#define _EXTERN_INLINE extern __inline
+#endif
+
+/* Returns the descriptor cell for FD.  If FD is invalid or unused, return
+   NULL.  The cell is unlocked; when ready to use it, lock it and check for
+   it being unused.  */
+
+_EXTERN_INLINE struct hurd_fd *
+_hurd_fd_get (int fd)
+{
+  struct hurd_fd *descriptor;
+
+  __mutex_lock (&_hurd_dtable_lock);
+  if (fd < 0 || fd >= _hurd_dtablesize)
+    descriptor = NULL;
+  else
+    {
+      struct hurd_fd *cell = _hurd_dtable[fd];
+      if (cell == NULL)
+	/* No descriptor allocated at this index.  */
+	descriptor = NULL;
+      else
+	{
+	  __spin_lock (&cell->port.lock);
+	  if (cell->port.port == MACH_PORT_NULL)
+	    /* The descriptor at this index has no port in it.
+	       This happens if it existed before but was closed.  */
+	    descriptor = NULL;
+	  else
+	    descriptor = cell;
+	  __spin_unlock (&cell->port.lock);
+	}
+    }
+  __mutex_unlock (&_hurd_dtable_lock);
+
+  return descriptor;
+}
+
+
+/* Evaluate EXPR with the variable `descriptor' bound to a pointer to the
+   file descriptor structure for FD.   */
+
+#define	HURD_FD_USE(fd, expr)						      \
+  ({ struct hurd_fd *descriptor = _hurd_fd_get (fd);			      \
+     descriptor == NULL ? EBADF : (expr); })
+
+/* Evaluate EXPR with the variable `port' bound to the port to FD, and
+   `ctty' bound to the ctty port.  */
+
+#define HURD_DPORT_USE(fd, expr) \
+  HURD_FD_USE ((fd), HURD_FD_PORT_USE (descriptor, (expr)))
+
+/* Likewise, but FD is a pointer to the file descriptor structure.  */
+
+#define	HURD_FD_PORT_USE(fd, expr)					      \
+  ({ error_t __result;							      \
+     struct hurd_fd *const __d = (fd);					      \
+     struct hurd_userlink __ulink, __ctty_ulink;			      \
+     io_t port, ctty;							      \
+     void *crit = _hurd_critical_section_lock ();			      \
+     __spin_lock (&__d->port.lock);					      \
+     if (__d->port.port == MACH_PORT_NULL)				      \
+       {								      \
+	 __spin_unlock (&__d->port.lock);				      \
+	 _hurd_critical_section_unlock (crit);				      \
+	 __result = EBADF;						      \
+       }								      \
+     else								      \
+       {								      \
+	 ctty = _hurd_port_get (&__d->ctty, &__ctty_ulink);		      \
+	 port = _hurd_port_locked_get (&__d->port, &__ulink);		      \
+	 _hurd_critical_section_unlock (crit);				      \
+	 __result = (expr);						      \
+	 _hurd_port_free (&__d->port, &__ulink, port);			      \
+	 if (ctty != MACH_PORT_NULL)					      \
+	   _hurd_port_free (&__d->ctty, &__ctty_ulink, ctty);		      \
+       }								      \
+     __result; })
+
+#include <errno.h>
+
+/* Check if ERR should generate a signal.
+   Returns the signal to take, or zero if none.  */
+
+_EXTERN_INLINE error_t
+_hurd_fd_error_signal (error_t err)
+{
+  switch (err)
+    {
+    case EMACH_SEND_INVALID_DEST:
+    case EMIG_SERVER_DIED:
+      /* The server has disappeared!  */
+      return SIGLOST;
+    case EPIPE:
+      return SIGPIPE;
+    default:
+      /* Having a default case avoids -Wenum-switch warnings.  */
+      return 0;
+    }
+}
+
+/* Handle an error from an RPC on a file descriptor's port.  You should
+   always use this function to handle errors from RPCs made on file
+   descriptor ports.  Some errors are translated into signals.  */   
+
+_EXTERN_INLINE error_t
+_hurd_fd_error (int fd, error_t err)
+{
+  int signo = _hurd_fd_error_signal (err);
+  if (signo)
+    _hurd_raise_signal (NULL, signo, fd, err);
+  return err;
+}
+
+/* Handle error code ERR from an RPC on file descriptor FD's port.
+   Set `errno' to the appropriate error code, and always return -1.  */
+
+_EXTERN_INLINE int
+__hurd_dfail (int fd, error_t err)
+{
+  errno = _hurd_fd_error (fd, err);
+  return -1;
+}
+
+/* Set up *FD to have PORT its server port, doing appropriate ctty magic.
+   Does no locking or unlocking.  */
+
+extern void _hurd_port2fd (struct hurd_fd *fd, io_t port, int flags);
+
+/* Allocate a new file descriptor and install PORT in it (doing any
+   appropriate ctty magic); consumes a user reference on PORT.  FLAGS are
+   as for `open'; only O_IGNORE_CTTY is meaningful, but all are saved.
+
+   If the descriptor table is full, set errno, and return -1.
+   If DEALLOC is nonzero, deallocate PORT first.  */
+
+extern int _hurd_intern_fd (io_t port, int flags, int dealloc);
+
+/* Allocate a new file descriptor in the table and return it, locked.  The
+   new descriptor number will be no less than FIRST_FD.  If the table is
+   full, set errno to EMFILE and return NULL.  If FIRST_FD is negative or
+   bigger than the size of the table, set errno to EINVAL and return NULL.  */
+
+extern struct hurd_fd *_hurd_alloc_fd (int *fd_ptr, int first_fd);
+
+/* Allocate a new file descriptor structure and initialize its port cells
+   with PORT and CTTY.  (This does not affect the descriptor table.)  */
+
+extern struct hurd_fd *_hurd_new_fd (io_t port, io_t ctty);
+
+/* Close a file descriptor, making it available for future reallocation.  */
+
+extern error_t _hurd_fd_close (struct hurd_fd *fd);
+
+/* Read and write data from a file descriptor; just like `read' and `write'.
+   If successful, stores the amount actually read or written in *NBYTES.  */
+
+extern error_t _hurd_fd_read (struct hurd_fd *fd, void *buf, size_t *nbytes);
+extern error_t _hurd_fd_write (struct hurd_fd *fd,
+			       const void *buf, size_t *nbytes);
+
+
+/* Call *RPC on PORT and/or CTTY; if a call on CTTY returns EBACKGROUND,
+   generate SIGTTIN/SIGTTOU or EIO as appropriate.  */
+
+extern error_t _hurd_ctty_input (io_t port, io_t ctty, error_t (*rpc) (io_t));
+extern error_t _hurd_ctty_output (io_t port, io_t ctty, error_t (*rpc) (io_t));
+
+
+#endif	/* hurd/fd.h */
diff --git a/hurd/hurd/id.h b/hurd/hurd/id.h
new file mode 100644
index 0000000..7a50081
--- /dev/null
+++ b/hurd/hurd/id.h
@@ -0,0 +1,55 @@
+/* User and group IDs.
+Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_ID_H
+
+#define	_HURD_ID_H	1
+#include <features.h>
+
+#include <cthreads.h>		/* For `struct mutex'.  */
+
+/* Structure describing authorization data for the process.  */
+
+struct hurd_id_data
+  {
+    struct mutex lock;
+
+    int valid;			/* If following data are up to date.  */
+
+    struct
+      {
+	uid_t *uids;
+	gid_t *gids;
+	mach_msg_type_number_t nuids, ngids;
+      } gen, aux;
+
+    auth_t rid_auth;		/* Cache used by access.  */
+  };
+
+/* Current data.  */
+
+extern struct hurd_id_data _hurd_id;
+
+
+/* Update _hurd_id (caller should be holding the lock).  */
+
+extern error_t _hurd_check_ids (void);
+
+
+#endif	/* hurd/id.h */
diff --git a/hurd/hurd/ioctl.h b/hurd/hurd/ioctl.h
new file mode 100644
index 0000000..cc83433
--- /dev/null
+++ b/hurd/hurd/ioctl.h
@@ -0,0 +1,71 @@
+/* User-registered handlers for specific `ioctl' requests.
+Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_IOCTL_H
+#define	_HURD_IOCTL_H	1
+
+#define	__need___va_list
+#include <stdarg.h>
+
+
+/* Type of handler function, called like ioctl to do its entire job.  */
+typedef int (*ioctl_handler_t) (int fd, int request, void *arg);
+
+/* Structure that records an ioctl handler.  */
+struct ioctl_handler
+  {
+    int first_request, last_request; /* Range of handled request values.  */
+
+    /* Handler function, called like ioctl to do its entire job.  */
+    ioctl_handler_t handler;
+
+    struct ioctl_handler *next;	/* Next handler.  */
+  };
+
+
+/* Register HANDLER to handle ioctls with REQUEST values between
+   FIRST_REQUEST and LAST_REQUEST inclusive.  Returns zero if successful.
+   Return nonzero and sets `errno' for an error.  */
+
+extern int hurd_register_ioctl_handler (int first_request, int last_request,
+					ioctl_handler_t handler);
+
+
+/* Define a library-internal handler for ioctl commands between FIRST and
+   LAST inclusive.  The last element gratuitously references HANDLER to
+   avoid `defined but not used' warnings.  */
+
+#define	_HURD_HANDLE_IOCTLS(handler, first, last)			      \
+  static const struct ioctl_handler handler##_ioctl_handler =		      \
+    { (first), (last), (int (*) (int, int, void *)) (handler),	      \
+	(&(handler), &(handler##_ioctl_handler), NULL) };		      \
+  text_set_element (_hurd_ioctl_handler_lists, ##handler##_ioctl_handler)
+
+/* Define a library-internal handler for a single ioctl command.  */
+
+#define _HURD_HANDLE_IOCTL(handler, ioctl) \
+  _HURD_HANDLE_IOCTLS (handler, (ioctl), (ioctl))
+
+
+/* Lookup the handler for the given ioctl request.  */
+
+ioctl_handler_t _hurd_lookup_ioctl_handler (int request);
+
+
+#endif	/* hurd/ioctl.h */
diff --git a/hurd/hurd/port.h b/hurd/hurd/port.h
new file mode 100644
index 0000000..a057503
--- /dev/null
+++ b/hurd/hurd/port.h
@@ -0,0 +1,152 @@
+/* Lightweight user references for ports.
+Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_PORT_H
+
+#define	_HURD_PORT_H	1
+#include <features.h>
+
+#include <mach.h>
+#include <hurd/userlink.h>
+#include <spin-lock.h>
+#include <hurd/signal.h>
+
+
+/* Structure describing a cell containing a port.  With the lock held, a
+   user extracts PORT, and attaches his own link (in local storage) to the
+   USERS chain.  PORT can then safely be used.  When PORT is no longer
+   needed, with the lock held, the user removes his link from the chain.
+   If his link is the last, and PORT has changed since he fetched it, the
+   user deallocates the port he used.  See <hurd/userlink.h>.  */
+
+struct hurd_port
+  {
+    spin_lock_t lock;		/* Locks rest.  */
+    struct hurd_userlink *users; /* Chain of users; see below.  */
+    mach_port_t port;		/* Port. */
+  };
+
+
+/* Evaluate EXPR with the variable `port' bound to the port in PORTCELL.  */
+
+#define	HURD_PORT_USE(portcell, expr)					      \
+  ({ struct hurd_port *const __p = (portcell);				      \
+     struct hurd_userlink __link;					      \
+     const mach_port_t port = _hurd_port_get (__p, &__link);		      \
+     __typeof(expr) __result = (expr);					      \
+     _hurd_port_free (__p, &__link, port);				      \
+     __result; })
+
+
+#ifndef _EXTERN_INLINE
+#define _EXTERN_INLINE extern __inline
+#endif
+
+
+/* Initialize *PORT to INIT.  */
+
+_EXTERN_INLINE void
+_hurd_port_init (struct hurd_port *port, mach_port_t init)
+{
+  __spin_lock_init (&port->lock);
+  port->users = NULL;
+  port->port = init;
+}
+
+
+/* Get a reference to *PORT, which is locked.
+   Pass return value and LINK to _hurd_port_free when done.  */
+
+_EXTERN_INLINE mach_port_t
+_hurd_port_locked_get (struct hurd_port *port,
+		       struct hurd_userlink *link)
+{
+  mach_port_t result;
+  result = port->port;
+  if (result != MACH_PORT_NULL)
+    _hurd_userlink_link (&port->users, link);
+  __spin_unlock (&port->lock);
+  return result;
+}
+
+/* Same, but locks PORT first.  */
+
+_EXTERN_INLINE mach_port_t
+_hurd_port_get (struct hurd_port *port,
+		struct hurd_userlink *link)
+{
+  mach_port_t result;
+  HURD_CRITICAL_BEGIN;
+  __spin_lock (&port->lock);
+  result = _hurd_port_locked_get (port, link);
+  HURD_CRITICAL_END;
+  return result;
+}
+
+
+/* Free a reference gotten with `USED_PORT = _hurd_port_get (PORT, LINK);' */
+
+_EXTERN_INLINE void
+_hurd_port_free (struct hurd_port *port,
+		 struct hurd_userlink *link,
+		 mach_port_t used_port)
+{
+  int dealloc;
+  if (used_port == MACH_PORT_NULL)
+    /* When we fetch an empty port cell with _hurd_port_get,
+       it does not link us on the users chain, since there is
+       no shared resource.  */
+    return;
+  HURD_CRITICAL_BEGIN;
+  __spin_lock (&port->lock);
+  dealloc = _hurd_userlink_unlink (link);
+  __spin_unlock (&port->lock);
+  HURD_CRITICAL_END;
+  if (dealloc)
+    __mach_port_deallocate (__mach_task_self (), used_port);
+}
+
+
+/* Set *PORT's port to NEWPORT.  NEWPORT's reference is consumed by PORT->port.
+   PORT->lock is locked.  */
+
+_EXTERN_INLINE void
+_hurd_port_locked_set (struct hurd_port *port, mach_port_t newport)
+{
+  mach_port_t old;
+  old = _hurd_userlink_clear (&port->users) ? port->port : MACH_PORT_NULL;
+  port->port = newport;
+  __spin_unlock (&port->lock);
+  if (old != MACH_PORT_NULL)
+    __mach_port_deallocate (__mach_task_self (), old);
+}
+
+/* Same, but locks PORT first.  */
+
+_EXTERN_INLINE void
+_hurd_port_set (struct hurd_port *port, mach_port_t newport)
+{
+  HURD_CRITICAL_BEGIN;
+  __spin_lock (&port->lock);
+  _hurd_port_locked_set (port, newport);
+  HURD_CRITICAL_END;
+}
+
+
+#endif	/* hurd/port.h */
diff --git a/hurd/hurd/resource.h b/hurd/hurd/resource.h
new file mode 100644
index 0000000..ad2a61a
--- /dev/null
+++ b/hurd/hurd/resource.h
@@ -0,0 +1,50 @@
+/* Resource limits for the Hurd.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef _HURD_RESOURCE_H
+#define _HURD_RESOURCE_H
+
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <errno.h>
+#include <hurd/process.h>
+
+/* This array contains the current resource limits for the process.  */
+extern struct rlimit _hurd_rlimits[RLIM_NLIMITS];
+extern struct mutex _hurd_rlimit_lock; /* Locks _hurd_rlimits.  */
+
+
+/* Helper function for getpriority and setpriority.  Maps FN over all the
+   processes specified by WHICH and WHO.  PI is non-null if a
+   proc_getprocinfo was already done; FN may use *PI arbitrarily, it is
+   reset on the next call.  Returns FN's result the first time it returns
+   nonzero.  If FN never returns nonzero, this returns zero.  */
+extern error_t _hurd_priority_which_map (enum __priority_which which, int who,
+					 error_t (*fn) (pid_t pid,
+							struct procinfo *pi));
+
+/* Convert between Mach priority values and the priority
+   values used by getpriority, setpriority, and nice.  */
+#define MACH_PRIORITY_TO_NICE(prio) (2 * ((prio) - 12))
+#define NICE_TO_MACH_PRIORITY(nice) (12 + ((nice) / 2))
+
+
+
+
+#endif
diff --git a/hurd/hurd/signal.h b/hurd/hurd/signal.h
new file mode 100644
index 0000000..76007d5
--- /dev/null
+++ b/hurd/hurd/signal.h
@@ -0,0 +1,391 @@
+/* Implementing POSIX.1 signals under the Hurd.
+Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_SIGNAL_H
+
+#define	_HURD_SIGNAL_H	1
+#include <features.h>
+/* Make sure <signal.h> is going to define NSIG.  */
+#ifndef __USE_GNU
+#error "Must have `_GNU_SOURCE' feature test macro to use this file"
+#endif
+
+#define __need_NULL
+#include <stddef.h>
+
+#include <mach/mach_types.h>
+#include <mach/port.h>
+#include <mach/message.h>
+#include <hurd/hurd_types.h>
+#include <signal.h>
+#include <errno.h>
+#include <hurd/msg.h>
+
+#include <cthreads.h>		/* For `struct mutex'.  */
+#include <spin-lock.h>
+#include <hurd/threadvar.h>	/* We cache sigstate in a threadvar.  */
+
+
+/* Per-thread signal state.  */
+
+struct hurd_sigstate
+  {
+    spin_lock_t lock;		/* Locks most of the rest of the structure.  */
+
+    int critical_section;	/* Nonzero if in critical section.  */
+
+    thread_t thread;
+    struct hurd_sigstate *next; /* Linked-list of thread sigstates.  */
+
+    sigset_t blocked;		/* What signals are blocked.  */
+    sigset_t pending;		/* Pending signals, possibly blocked.  */
+    struct sigaction actions[NSIG];
+    struct sigaltstack sigaltstack;
+    struct
+      {
+	/* For each signal that may be pending, the
+	   sigcode and error code to deliver it with.  */
+	long int code;
+	error_t error;
+      } pending_data[NSIG];
+
+    /* If `suspended' is set when this thread gets a signal,
+       the signal thread sends an empty message to it.  */
+    mach_port_t suspended;
+
+    /* The following members are not locked.  They are used only by this
+       thread, or by the signal thread with this thread suspended.  */
+
+    volatile mach_port_t intr_port; /* Port interruptible RPC was sent on.  */
+
+    /* If this is not null, the thread is in sigreturn awaiting delivery of
+       pending signals.  This context (the machine-dependent portions only)
+       will be passed to sigreturn after running the handler for a pending
+       signal, instead of examining the thread state.  */
+    struct sigcontext *context;
+  };
+
+/* Linked list of states of all threads whose state has been asked for.  */
+
+extern struct hurd_sigstate *_hurd_sigstates;
+
+extern struct mutex _hurd_siglock; /* Locks _hurd_sigstates.  */
+
+/* Get the sigstate of a given thread, taking its lock.  */
+
+extern struct hurd_sigstate *_hurd_thread_sigstate (thread_t);
+
+/* Get the sigstate of the current thread.
+   This uses a per-thread variable to optimize the lookup.  */
+_EXTERN_INLINE struct hurd_sigstate *
+_hurd_self_sigstate (void)
+{
+  struct hurd_sigstate **location =
+    (void *) __hurd_threadvar_location (_HURD_THREADVAR_SIGSTATE);
+  if (*location == NULL)
+    *location = _hurd_thread_sigstate (__mach_thread_self ());
+  return *location;
+}
+
+/* Thread listening on our message port; also called the "signal thread".  */
+
+extern thread_t _hurd_msgport_thread;
+
+/* Our message port.  We hold the receive right and _hurd_msgport_thread
+   listens for messages on it.  We also hold a send right, for convenience.  */
+
+extern mach_port_t _hurd_msgport;
+
+
+/* Thread to receive process-global signals.  */
+
+extern thread_t _hurd_sigthread;
+
+
+/* Resource limit on core file size.  Enforced by hurdsig.c.  */
+extern int _hurd_core_limit;
+
+/* Critical sections.
+
+   A critical section is a section of code which cannot safely be interrupted
+   to run a signal handler; for example, code that holds any lock cannot be
+   interrupted lest the signal handler try to take the same lock and
+   deadlock result.  */
+
+_EXTERN_INLINE void *
+_hurd_critical_section_lock (void)
+{
+  struct hurd_sigstate **location =
+    (void *) __hurd_threadvar_location (_HURD_THREADVAR_SIGSTATE);
+  struct hurd_sigstate *ss = *location;
+  if (ss == NULL)
+    /* The thread variable is unset; this must be the first time we've
+       asked for it.  In this case, the critical section flag cannot
+       possible already be set.  Look up our sigstate structure the slow
+       way; this locks the sigstate lock.  */
+    ss = *location = _hurd_thread_sigstate (__mach_thread_self ());
+  else
+    __spin_lock (&ss->lock);
+
+  if (ss->critical_section)
+    {
+      /* We are already in a critical section, so do nothing.  */
+      __spin_unlock (&ss->lock);
+      return NULL;
+    }
+
+  /* Set the critical section flag so no signal handler will run.  */
+  ss->critical_section = 1;
+  __spin_unlock (&ss->lock);
+
+  /* Return our sigstate pointer; this will be passed to
+     _hurd_critical_section_unlock to clear the critical section flag. */
+  return ss;
+}
+
+_EXTERN_INLINE void
+_hurd_critical_section_unlock (void *our_lock)
+{
+  if (our_lock == NULL)
+    /* The critical section lock was held when we began.  Do nothing.  */
+    return;
+  else
+    {
+      /* It was us who acquired the critical section lock.  Clear the
+	 critical section flag.  */
+      struct hurd_sigstate *ss = our_lock;
+      sigset_t pending;
+      __spin_lock (&ss->lock);
+      ss->critical_section = 0;
+      pending = ss->pending & ~ss->blocked;
+      __spin_unlock (&ss->lock);
+      if (pending)
+	/* There are unblocked signals pending, which weren't
+	   delivered because we were in the critical section.
+	   Tell the signal thread to deliver them now.  */
+	__msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+    }
+}
+
+/* Convenient macros for simple uses of critical sections.
+   These two must be used as a pair at the same C scoping level.  */
+
+#define HURD_CRITICAL_BEGIN \
+  { void *__hurd_critical__ = _hurd_critical_section_lock ()
+#define HURD_CRITICAL_END \
+      _hurd_critical_section_unlock (__hurd_critical__); } while (0)
+
+/* Initialize the signal code, and start the signal thread.  */
+
+extern void _hurdsig_init (void);
+
+/* Initialize proc server-assisted fault recovery for the signal thread.  */
+
+extern void _hurdsig_fault_init (void);
+
+/* Raise a signal as described by SIGNO, SIGCODE and SIGERROR, on the
+   thread whose sigstate SS points to.  If SS is a null pointer, this
+   instead affects the calling thread.  */
+
+extern void _hurd_raise_signal (struct hurd_sigstate *ss,
+				int signo, long int sigcode, int sigerror);
+
+/* Translate a Mach exception into a signal (machine-dependent).  */
+
+extern void _hurd_exception2signal (int exception, int code, int subcode,
+				    int *signo, long int *sigcode, int *error);
+
+
+/* Make the thread described by SS take the signal described by SIGNO and
+   SIGCODE.  If the process is traced, this will in fact stop with a SIGNO
+   as the stop signal unless UNTRACED is nonzero.  When the signal can be
+   considered delivered, sends a sig_post reply message on REPLY_PORT
+   indicating success.  SS is not locked.  */
+
+extern void _hurd_internal_post_signal (struct hurd_sigstate *ss,
+					int signo, long int sigcode, int error,
+					mach_port_t reply_port,
+					mach_msg_type_name_t reply_port_type,
+					int untraced);
+
+/* Set up STATE and SS to handle signal SIGNO by running HANDLER.  If
+   RPC_WAIT is nonzero, the thread needs to wait for a pending RPC to
+   finish before running the signal handler.  The handler is passed SIGNO,
+   SIGCODE, and the returned `struct sigcontext' (which resides on the
+   stack the handler will use, and which describes the state of the thread
+   encoded in STATE before running the handler).  */
+
+struct machine_thread_all_state;
+extern struct sigcontext *
+_hurd_setup_sighandler (struct hurd_sigstate *ss, __sighandler_t handler,
+			int signo, long int sigcode,
+			int rpc_wait, struct machine_thread_all_state *state);
+
+/* Function run by the signal thread to receive from the signal port.  */
+
+extern void _hurd_msgport_receive (void);
+
+/* STATE describes a thread that had intr_port set (meaning it was inside
+   HURD_EINTR_RPC), after it has been thread_abort'd.  It it looks to have
+   just completed a mach_msg_trap system call that returned
+   MACH_RCV_INTERRUPTED, return nonzero and set *PORT to the receive right
+   being waited on.  */
+
+extern int _hurdsig_rcv_interrupted_p (struct machine_thread_all_state *state,
+				       mach_port_t *port);
+
+/* Set up STATE with a thread state that, when resumed, is
+   like `longjmp (_hurd_sigthread_fault_env, 1)'.  */
+
+extern void _hurd_initialize_fault_recovery_state (void *state);
+
+
+/* Function run for SIGINFO when its action is SIG_DFL and the current
+   process is the session leader.  */
+
+extern void _hurd_siginfo_handler (int);
+
+
+/* Perform interruptible RPC CALL on PORT.
+   The call should use 
+   The args in CALL should be constant or local variable refs.
+   They may be evaluated many times, and must not change.
+   PORT must not be deallocated before this RPC is finished.  */
+#define	HURD_EINTR_RPC(port, call)					      \
+  ({									      \
+    __label__ __do_call;	/* Give this label block scope.  */	      \
+    error_t __err;							      \
+    struct hurd_sigstate *__ss = _hurd_self_sigstate ();		      \
+    __do_call:								      \
+    /* Tell the signal thread that we are doing an interruptible RPC on	      \
+       this port.  If we get a signal and should return EINTR, the signal     \
+       thread will set this variable to MACH_PORT_NULL.  The RPC might	      \
+       return EINTR when some other thread gets a signal, in which case we    \
+       want to restart our call.  */					      \
+    __ss->intr_port = (port);						      \
+    /* A signal may arrive here, after intr_port is set, but before the	      \
+       mach_msg system call.  The signal handler might do an interruptible    \
+       RPC, and clobber intr_port; then it would not be set properly when     \
+       we actually did send the RPC, and a later signal wouldn't interrupt    \
+       that RPC.  So, _hurd_setup_sighandler saves intr_port in the	      \
+       sigcontext, and sigreturn restores it.  */			      \
+    switch (__err = (call))						      \
+      {									      \
+      case EINTR:		/* RPC went out and was interrupted.  */      \
+      case MACH_SEND_INTERRUPTED: /* RPC didn't get out.  */		      \
+	if (__ss->intr_port != MACH_PORT_NULL)				      \
+	  /* If this signal was for us and it should interrupt calls, the     \
+             signal thread will have cleared SS->intr_port.  Since it's not   \
+             cleared, the signal was for another thread, or SA_RESTART is     \
+             set.  Restart the interrupted call.  */			      \
+	  goto __do_call;						      \
+	/* FALLTHROUGH */						      \
+      case MACH_RCV_PORT_DIED:						      \
+	/* Server didn't respond to interrupt_operation,		      \
+	   so the signal thread destroyed the reply port.  */		      \
+	__err = EINTR;							      \
+	break;								      \
+      default:			/* Quiet -Wswitch-enum.  */		      \
+      }									      \
+    __ss->intr_port = MACH_PORT_NULL;					      \
+    __err;								      \
+  })									      \
+
+
+/* Mask of signals that cannot be caught, blocked, or ignored.  */
+#define	_SIG_CANT_MASK	(__sigmask (SIGSTOP) | __sigmask (SIGKILL))
+
+/* Do an RPC to a process's message port.
+
+   Each argument is an expression which returns an error code; each
+   expression may be evaluated several times.  FETCH_MSGPORT_EXPR should
+   fetch the appropriate message port and store it in the local variable
+   `msgport'; it will be deallocated after use.  FETCH_REFPORT_EXPR should
+   fetch the appropriate message port and store it in the local variable
+   `refport' (if no reference port is needed in the call, then
+   FETCH_REFPORT_EXPR should be simply KERN_SUCCESS or 0); if
+   DEALLOC_REFPORT evaluates to nonzero it will be deallocated after use,
+   otherwise the FETCH_REFPORT_EXPR must take care of user references to
+   `refport'.  RPC_EXPR should perform the desired RPC operation using
+   `msgport' and `refport'.
+
+   The reason for the complexity is that a process's message port and
+   reference port may change between fetching those ports and completing an
+   RPC using them (usually they change only when a process execs).  The RPC
+   will fail with MACH_SEND_INVALID_DEST if the msgport dies before we can
+   send the RPC request; or with MIG_SERVER_DIED if the msgport was
+   destroyed after we sent the RPC request but before it was serviced.  In
+   either of these cases, we retry the entire operation, discarding the old
+   message and reference ports and fetch them anew.  */
+
+#define HURD_MSGPORT_RPC(fetch_msgport_expr,				      \
+			 fetch_refport_expr, dealloc_refport,		      \
+			 rpc_expr) 					      \
+({									      \
+    error_t __err;							      \
+    mach_port_t msgport, refport = MACH_PORT_NULL;			      \
+    do									      \
+      {									      \
+	/* Get the message port.  */					      \
+	if (__err = (fetch_msgport_expr))				      \
+	  break;							      \
+	/* Get the reference port.  */					      \
+	if (__err = (fetch_refport_expr))				      \
+	  {								      \
+	    /* Couldn't get it; deallocate MSGPORT and fail.  */	      \
+	    __mach_port_deallocate (__mach_task_self (), msgport);	      \
+	    break;							      \
+	  }								      \
+	__err = (rpc_expr);						      \
+	__mach_port_deallocate (__mach_task_self (), msgport);		      \
+	if ((dealloc_refport) && refport != MACH_PORT_NULL)		      \
+	  __mach_port_deallocate (__mach_task_self (), refport);    	      \
+      } while (__err == MACH_SEND_INVALID_DEST ||			      \
+	       __err == MIG_SERVER_DIED);				      \
+    __err;								      \
+})
+
+/* Some other parts of the library need to preempt signals, to detect
+   errors that should not result in a POSIX signal.  For example, when
+   some mapped region of memory is used, an extraneous SIGSEGV might be
+   generated when the mapping server returns an error for a page fault.  */
+
+struct hurd_signal_preempt
+  {
+    /* Function to examine a thread receiving a given signal.  The handler
+       is called even for blocked signals.  This function is run in the
+       signal thread, with THREAD's sigstate locked; it should be as simple
+       and robust as possible.  THREAD is the thread which is about to
+       receive the signal.  SIGNO and SIGCODE would be passed to the normal
+       handler.
+
+       If the return value is SIG_DFL, normal signal processing continues.
+       If it is SIG_IGN, the signal is ignored.
+       Any other value is used in place of the normal handler.  */
+    sighandler_t (*handler) (thread_t thread,
+			     int signo, long int sigcode, int sigerror);
+    long int first, last;	/* Range of sigcodes this handler wants.  */
+    struct hurd_signal_preempt *next; /* Next handler on the chain. */
+  };
+
+extern struct hurd_signal_preempt *_hurd_signal_preempt[NSIG];
+extern struct mutex _hurd_signal_preempt_lock;
+
+
+#endif	/* hurd/signal.h */
diff --git a/hurd/hurd/threadvar.h b/hurd/hurd/threadvar.h
new file mode 100644
index 0000000..eab133a
--- /dev/null
+++ b/hurd/hurd/threadvar.h
@@ -0,0 +1,107 @@
+/* Internal per-thread variables for the Hurd.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef _HURD_THREADVAR_H
+#define	_HURD_THREADVAR_H
+
+/* The per-thread variables are found by ANDing this mask
+   with the value of the stack pointer and then adding this offset.
+
+   In the multi-threaded case, cthreads initialization sets
+   __hurd_threadvar_stack_mask to ~(cthread_stack_size - 1), a mask which
+   finds the base of the fixed-size cthreads stack; and
+   __hurd_threadvar_stack_offset to a small offset that skips the data
+   cthreads itself maintains at the base of each thread's stack.
+
+   In the single-threaded case, __hurd_threadvar_stack_mask is zero, so the
+   stack pointer is ignored; and __hurd_threadvar_stack_offset gives the
+   address of a small allocated region which contains the variables for the
+   single thread.  */
+   
+extern unsigned long int __hurd_threadvar_stack_mask;
+extern unsigned long int __hurd_threadvar_stack_offset;
+
+/* A special case must always be made for the signal thread.  Even when there
+   is only one user thread and an allocated region can be used for the user
+   thread's variables, the signal thread needs to have its own location for
+   per-thread variables.  The variables __hurd_sigthread_stack_base and
+   __hurd_sigthread_stack_end define the bounds of the stack used by the
+   signal thread, so that thread can always be specifically identified.  */
+
+extern unsigned long int __hurd_sigthread_stack_base;
+extern unsigned long int __hurd_sigthread_stack_end;
+extern unsigned long int *__hurd_sigthread_variables;
+
+
+/* At the location described by the two variables above,
+   there are __hurd_threadvar_max `unsigned long int's of per-thread data.  */
+extern unsigned int __hurd_threadvar_max;
+
+/* These values are the indices for the standard per-thread variables.  */
+enum __hurd_threadvar_index
+  {
+    _HURD_THREADVAR_MIG_REPLY,	/* Reply port for MiG user stub functions.  */
+    _HURD_THREADVAR_ERRNO,	/* `errno' value for this thread.  */
+    _HURD_THREADVAR_SIGSTATE,	/* This thread's `struct hurd_sigstate'.  */
+    _HURD_THREADVAR_DYNAMIC_USER, /* Dynamically-assigned user variables. */
+    _HURD_THREADVAR_MAX		/* Default value for __hurd_threadvar_max.  */
+  };
+
+
+#ifndef _EXTERN_INLINE
+#define _EXTERN_INLINE extern __inline
+#endif
+
+/* Return the location of the value for the per-thread variable with index
+   INDEX used by the thread whose stack pointer is SP.  */
+
+_EXTERN_INLINE unsigned long int *
+__hurd_threadvar_location_from_sp (enum __hurd_threadvar_index __index,
+				   void *__sp)
+{
+  unsigned long int __stack = (unsigned long int) __sp;
+  return &((__stack >= __hurd_sigthread_stack_base &&
+	    __stack < __hurd_sigthread_stack_end)
+	   ? __hurd_sigthread_variables
+	   : (unsigned long int *) ((__stack & __hurd_threadvar_stack_mask) +
+				    __hurd_threadvar_stack_offset))[__index];
+}
+
+#include <machine-sp.h>		/* Define __thread_stack_pointer.  */
+
+/* Return the location of the current thread's value for the
+   per-thread variable with index INDEX.  */
+
+_EXTERN_INLINE unsigned long int *
+__hurd_threadvar_location (enum __hurd_threadvar_index __index)
+{
+  return __hurd_threadvar_location_from_sp (__index,
+					    __thread_stack_pointer ());
+}
+
+/* Return the current thread's location for `errno'.
+   The syntax of this function allows redeclarations like `int errno'.  */
+_EXTERN_INLINE int *
+__hurd_errno_location (void)
+{
+  return (int *) __hurd_threadvar_location (_HURD_THREADVAR_ERRNO);
+}
+
+
+#endif	/* hurd/threadvar.h */
diff --git a/hurd/hurd/userlink.h b/hurd/hurd/userlink.h
new file mode 100644
index 0000000..337d46a
--- /dev/null
+++ b/hurd/hurd/userlink.h
@@ -0,0 +1,105 @@
+/* Support for chains recording users of a resource; `struct hurd_userlink'.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef	_HURD_USERLINK_H
+
+#define	_HURD_USERLINK_H	1
+#include <features.h>
+
+#define __need_NULL
+#include <stddef.h>
+
+
+/* This structure is simply a doubly-linked list.  Users of a given
+   resource are recorded by their presence in a list associated with that
+   resource.  A user attaches his own link (in local storage) to a shared
+   chain at the time he begins using some resource.  When finished with
+   that resource, the user removes his link from the chain.  If his link is
+   the last (there are no other users of the resource), and his chain has
+   been detached from the shared cell (the resource in the cell has been
+   replaced), then the user deallocates the resource that he used.  */
+
+struct hurd_userlink
+  {
+    struct hurd_userlink *next, **prevp;
+  };
+
+
+#ifndef _EXTERN_INLINE
+#define _EXTERN_INLINE extern __inline
+#endif
+
+
+/* Attach LINK to the chain of users at *CHAINP.  */
+
+_EXTERN_INLINE void
+_hurd_userlink_link (struct hurd_userlink **chainp,
+		     struct hurd_userlink *link)
+{
+  link->next = *chainp;
+  if (link->next)
+    link->next->prevp = &link->next;
+  link->prevp = chainp;
+  *chainp = link;
+}
+
+
+/* Detach LINK from its chain.  If the return value is nonzero, the caller
+   should deallocate the resource he started using after attaching LINK to
+   the chain it's on.  If the return value is zero, then someone else is
+   still using the resource.  */
+
+_EXTERN_INLINE int
+_hurd_userlink_unlink (struct hurd_userlink *link)
+{
+  /* The caller should deallocate the resource he used if his chain has
+     been detached from the cell (and thus has a nil `prevp'), and there is
+     no next link representing another user reference to the same resource. */
+  int dealloc = ! link->next && ! link->prevp;
+
+  /* Remove our link from the chain of current users.  */
+  if (link->prevp)
+    *link->prevp = link->next;
+  if (link->next)
+    link->next->prevp = link->prevp;
+
+  return dealloc;
+}
+
+
+/* Clear all users from *CHAINP.  Call this when the resource *CHAINP
+   protects is changing.  If the return value is nonzero, no users are on
+   the chain and the caller should deallocate the resource.  If the return
+   value is zero, someone is still using the resource and they will
+   deallocate it when they are finished.  */
+
+_EXTERN_INLINE int
+_hurd_userlink_clear (struct hurd_userlink **chainp)
+{
+  if (*chainp == NULL)
+    return 1;
+
+  /* Detach the chain of current users from the cell.  The last user to
+     remove his link from that chain will deallocate the old resource.  */
+  (*chainp)->prevp = NULL;
+  *chainp = NULL;
+  return 0;
+}
+
+#endif	/* hurd/userlink.h */
diff --git a/hurd/hurdauth.c b/hurd/hurdauth.c
new file mode 100644
index 0000000..db93fd6
--- /dev/null
+++ b/hurd/hurdauth.c
@@ -0,0 +1,130 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/msg_server.h>
+#include <hurd/id.h>
+#include <string.h>
+
+int
+_hurd_refport_secure_p (mach_port_t ref)
+{
+  if (ref == __mach_task_self ())
+    return 1;
+  if (__USEPORT (AUTH, ref == port))
+    return 1;
+  return 0;
+}
+
+kern_return_t
+_S_msg_add_auth (mach_port_t me,
+		 auth_t addauth)
+{
+  error_t err;
+  auth_t newauth;
+
+  if (err = __USEPORT (AUTH,
+		       __auth_makeauth (port,
+					&addauth, 1, MACH_MSG_TYPE_MOVE_SEND,
+					NULL, 0,
+					NULL, 0,
+					NULL, 0,
+					NULL, 0,
+					&newauth)))
+    return err;
+
+  err = __setauth (newauth);
+  __mach_port_deallocate (__mach_task_self (), newauth);
+  if (err)
+    return errno;
+
+  return 0;
+}
+
+kern_return_t
+_S_msg_del_auth (mach_port_t me,
+		 task_t task,
+		 intarray_t uids, mach_msg_type_number_t nuids,
+		 intarray_t gids, mach_msg_type_number_t ngids)
+{
+  error_t err;
+  auth_t newauth;
+
+  if (!_hurd_refport_secure_p (task))
+    return EPERM;
+
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&_hurd_id.lock);
+  err = _hurd_check_ids ();
+
+  if (!err)
+    {
+      size_t i, j;
+      size_t nu = _hurd_id.gen.nuids, ng = _hurd_id.gen.ngids;
+      uid_t newu[nu];
+      gid_t newg[ng];
+
+      memcpy (newu, _hurd_id.gen.uids, nu * sizeof (uid_t));
+      memcpy (newg, _hurd_id.gen.gids, ng * sizeof (gid_t));
+
+      for (j = 0; j < nuids; ++j)
+	{
+	  const uid_t uid = uids[j];
+	  for (i = 0; i < nu; ++i)
+	    if (newu[i] == uid)
+	      /* Move the last uid into this slot, and decrease the
+		 number of uids so the last slot is no longer used.  */
+	      newu[i] = newu[--nu];
+	}
+      __vm_deallocate (__mach_task_self (),
+		       (vm_address_t) uids, nuids * sizeof (uid_t));
+
+      for (j = 0; j < ngids; ++j)
+	{
+	  const gid_t gid = gids[j];
+	  for (i = 0; i < nu; ++i)
+	    if (newu[i] == gid)
+	      /* Move the last gid into this slot, and decrease the
+		 number of gids so the last slot is no longer used.  */
+	      newu[i] = newu[--nu];
+	}
+      __vm_deallocate (__mach_task_self (),
+		       (vm_address_t) gids, ngids * sizeof (gid_t));
+
+      err = __USEPORT (AUTH, __auth_makeauth
+		       (port,
+			NULL, 0, MACH_MSG_TYPE_COPY_SEND,
+			newu, nu,
+			_hurd_id.aux.uids, _hurd_id.aux.nuids,
+			newg, ng,
+			_hurd_id.aux.uids, _hurd_id.aux.ngids,
+			&newauth));
+    }
+  __mutex_unlock (&_hurd_id.lock);
+  HURD_CRITICAL_END;
+
+  if (err)
+    return err;
+
+  err = __setauth (newauth);
+  __mach_port_deallocate (__mach_task_self (), newauth);
+  if (err)
+    return errno;
+
+  return 0;
+}
diff --git a/hurd/hurdexec.c b/hurd/hurdexec.c
new file mode 100644
index 0000000..d5d2d08
--- /dev/null
+++ b/hurd/hurdexec.c
@@ -0,0 +1,259 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <hurd.h>
+#include <hurd/fd.h>
+#include <hurd/signal.h>
+
+/* Overlay TASK, executing FILE with arguments ARGV and environment ENVP.
+   If TASK == mach_task_self (), some ports are dealloc'd by the exec server.
+   ARGV and ENVP are terminated by NULL pointers.  */
+error_t
+_hurd_exec (task_t task, file_t file, 
+	    char *const argv[], char *const envp[])
+{
+  error_t err;
+  char *args, *env, *ap;
+  size_t argslen, envlen;
+  int ints[INIT_INT_MAX];
+  mach_port_t ports[_hurd_nports];
+  struct hurd_userlink ulink_ports[_hurd_nports];
+  file_t *dtable;
+  int dtablesize;
+  struct hurd_port **dtable_cells;
+  struct hurd_userlink *ulink_dtable;
+  int i;
+  char *const *p;
+  struct hurd_sigstate *ss;
+  mach_port_t *please_dealloc, *pdp;
+
+
+  /* Pack the arguments into an array with nulls separating the elements.  */
+  argslen = 0;
+  if (argv != NULL)
+    {
+      p = argv;
+      while (*p != NULL)
+	argslen += strlen (*p++) + 1;
+      args = __alloca (argslen);
+      ap = args;
+      for (p = argv; *p != NULL; ++p)
+	ap = __memccpy (ap, *p, '\0', ULONG_MAX);
+    }
+  else
+    args = NULL;
+
+  /* Pack the environment into an array with nulls separating elements.  */
+  envlen = 0;
+  if (envp != NULL)
+    {
+      p = envp;
+      while (*p != NULL)
+	envlen += strlen (*p++) + 1;
+      env = __alloca (envlen);
+      ap = env;
+      for (p = envp; *p != NULL; ++p)
+	ap = __memccpy (ap, *p, '\0', ULONG_MAX);
+    }
+  else
+    env = NULL;
+
+  /* Load up the ports to give to the new program.  */
+  for (i = 0; i < _hurd_nports; ++i)
+    if (i == INIT_PORT_PROC && task != __mach_task_self ())
+      {
+	/* This is another task, so we need to ask the proc server
+	   for the right proc server port for it.  */
+	if (err = __USEPORT (PROC, __proc_task2proc (port, task, &ports[i])))
+	  {
+	    while (--i > 0)
+	      _hurd_port_free (&_hurd_ports[i], &ulink_ports[i], ports[i]);
+	    return err;
+	  }
+      }
+    else
+      ports[i] = _hurd_port_get (&_hurd_ports[i], &ulink_ports[i]);
+
+
+  /* Load up the ints to give the new program.  */
+  for (i = 0; i < INIT_INT_MAX; ++i)
+    switch (i)
+      {
+      case INIT_UMASK:
+	ints[i] = _hurd_umask;
+	break;
+
+      case INIT_SIGMASK:
+      case INIT_SIGIGN:
+      case INIT_SIGPENDING:
+	/* We will set these all below.  */
+	break;
+
+      default:
+	ints[i] = 0;
+      }
+
+  ss = _hurd_self_sigstate ();
+  __spin_lock (&ss->lock);
+  ints[INIT_SIGMASK] = ss->blocked;
+  ints[INIT_SIGPENDING] = ss->pending;
+  ints[INIT_SIGIGN] = 0;
+  for (i = 1; i < NSIG; ++i)
+    if (ss->actions[i].sa_handler == SIG_IGN)
+      ints[INIT_SIGIGN] |= __sigmask (i);
+
+  /* We hold the sigstate lock until the exec has failed so that no signal
+     can arrive between when we pack the blocked and ignored signals, and
+     when the exec actually happens.  A signal handler could change what
+     signals are blocked and ignored.  Either the change will be reflected
+     in the exec, or the signal will never be delivered.  Setting the
+     critical section flag avoids anything we call trying to acquire the
+     sigstate lock.  */
+  
+  ss->critical_section = 1;
+  __spin_unlock (&ss->lock);
+
+  /* Pack up the descriptor table to give the new program.  */
+  __mutex_lock (&_hurd_dtable_lock);
+
+  dtablesize = _hurd_dtable ? _hurd_dtablesize : _hurd_init_dtablesize;
+
+  if (task == __mach_task_self ())
+    /* Request the exec server to deallocate some ports from us if the exec
+       succeeds.  The init ports and descriptor ports will arrive in the
+       new program's exec_startup message.  If we failed to deallocate
+       them, the new program would have duplicate user references for them.
+       But we cannot deallocate them ourselves, because we must still have
+       them after a failed exec call.  */
+    please_dealloc = __alloca ((_hurd_nports + (2 * dtablesize))
+				* sizeof (mach_port_t));
+  else
+    please_dealloc = NULL;
+  pdp = please_dealloc;
+
+  if (_hurd_dtable != NULL)
+    {
+      dtable = __alloca (dtablesize * sizeof (dtable[0]));
+      ulink_dtable = __alloca (dtablesize * sizeof (ulink_dtable[0]));
+      dtable_cells = __alloca (dtablesize * sizeof (dtable_cells[0]));
+      for (i = 0; i < dtablesize; ++i)
+	{
+	  struct hurd_fd *const d = _hurd_dtable[i];
+	  if (d == NULL)
+	    {
+	      dtable[i] = MACH_PORT_NULL;
+	      continue;
+	    }
+	  __spin_lock (&d->port.lock);
+	  if (d->flags & FD_CLOEXEC)
+	    {
+	      /* This descriptor is marked to be closed on exec.
+		 So don't pass it to the new program.  */
+	      dtable[i] = MACH_PORT_NULL;
+	      if (pdp && d->port.port != MACH_PORT_NULL)
+		{
+		  /* We still need to deallocate the ports.  */
+		  *pdp++ = d->port.port;
+		  if (d->ctty.port != MACH_PORT_NULL)
+		    *pdp++ = d->ctty.port;
+		}
+	      __spin_unlock (&d->port.lock);
+	    }
+	  else
+	    {
+	      if (pdp && d->ctty.port != MACH_PORT_NULL)
+		/* All the elements of DTABLE are added to PLEASE_DEALLOC
+		   below, so we needn't add the port itself.
+		   But we must deallocate the ctty port as well as
+		   the normal port that got installed in DTABLE[I].  */
+		*pdp++ = d->ctty.port;
+	      dtable[i] = _hurd_port_locked_get (&d->port, &ulink_dtable[i]);
+	      dtable_cells[i] = &d->port;
+	    }
+	}
+    }
+  else
+    {
+      dtable = _hurd_init_dtable;
+      ulink_dtable = NULL;
+      dtable_cells = NULL;
+    }
+
+  /* The information is all set up now.  Try to exec the file.  */
+
+  {
+    if (pdp)
+      {
+	/* Request the exec server to deallocate some ports from us if the exec
+	   succeeds.  The init ports and descriptor ports will arrive in the
+	   new program's exec_startup message.  If we failed to deallocate
+	   them, the new program would have duplicate user references for them.
+	   But we cannot deallocate them ourselves, because we must still have
+	   them after a failed exec call.  */
+
+	for (i = 0; i < _hurd_nports; ++i)
+	  *pdp++ = ports[i];
+	for (i = 0; i < dtablesize; ++i)
+	  *pdp++ = dtable[i];
+      }
+
+    err = __file_exec (file, task,
+		       _hurd_exec_flags & EXEC_INHERITED,
+		       args, argslen, env, envlen,
+		       dtable, MACH_MSG_TYPE_COPY_SEND, dtablesize, 
+		       ports, MACH_MSG_TYPE_COPY_SEND, _hurd_nports, 
+		       ints, INIT_INT_MAX,
+		       please_dealloc, pdp - please_dealloc,
+		       NULL, 0);
+  }
+
+  /* Release references to the standard ports.  */
+  for (i = 0; i < _hurd_nports; ++i)
+    if (i == INIT_PORT_PROC && task != __mach_task_self ())
+      __mach_port_deallocate (__mach_task_self (), ports[i]);
+    else
+      _hurd_port_free (&_hurd_ports[i], &ulink_ports[i], ports[i]);
+
+  if (ulink_dtable != NULL)
+    /* Release references to the file descriptor ports.  */
+    for (i = 0; i < dtablesize; ++i)
+      if (dtable[i] != MACH_PORT_NULL)
+	_hurd_port_free (dtable_cells[i], &ulink_dtable[i], dtable[i]);
+
+  /* Release lock on the file descriptor table. */
+  __mutex_unlock (&_hurd_dtable_lock);
+
+  /* Safe to let signals happen now.  */
+  {
+    sigset_t pending;
+    __spin_lock (&ss->lock);
+    ss->critical_section = 0;
+    pending = ss->pending & ~ss->blocked;
+    __spin_unlock (&ss->lock);
+    if (pending)
+      __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+  }
+
+  return err;
+}
diff --git a/hurd/hurdfault.c b/hurd/hurdfault.c
new file mode 100644
index 0000000..e8b5466
--- /dev/null
+++ b/hurd/hurdfault.c
@@ -0,0 +1,143 @@
+/* Handle faults in the signal thread.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/signal.h>
+#include "hurdfault.h"
+#include <errno.h>
+#include <string.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include "thread_state.h"
+#include "faultexc.h"		/* mig-generated header for our exc server.  */
+
+jmp_buf _hurdsig_fault_env;
+
+static mach_port_t forward_sigexc;
+
+int _hurdsig_fault_expect_signo;
+long int _hurdsig_fault_sigcode;
+int _hurdsig_fault_sigerror;
+
+kern_return_t
+_hurdsig_fault_catch_exception_raise (mach_port_t port,
+				      thread_t thread,
+				      task_t task,
+				      int exception,
+				      int code,
+				      int subcode)
+{
+  int signo;
+
+  if (port != forward_sigexc ||
+      thread != _hurd_msgport_thread || task != __mach_task_self ())
+    return EPERM;		/* Strange bogosity.  */
+
+  /* Call the machine-dependent function to translate the Mach exception
+     codes into a signal number and subcode.  */
+  _hurd_exception2signal (exception, code, subcode, &signo,
+			  &_hurdsig_fault_sigcode, &_hurdsig_fault_sigerror);
+
+  return signo == _hurdsig_fault_expect_signo ? 0 : EGREGIOUS;
+}
+
+static void
+faulted (void)
+{
+  struct
+    {
+      mach_msg_header_t head;
+      char buf[64];
+    } request;
+  struct
+    {
+      mach_msg_header_t head;
+      mach_msg_type_t type;
+      int result;
+    } reply;
+  extern int _hurdsig_fault_exc_server (mach_msg_header_t *,
+					mach_msg_header_t *);
+
+ /* Wait for the exception_raise message forwarded by the proc server.  */
+
+ if (__mach_msg (&request.head, MACH_RCV_MSG, 0,
+		  sizeof request, forward_sigexc,
+		  MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL)
+      != MACH_MSG_SUCCESS)
+    __libc_fatal ("msg receive failed on signal thread exc\n");
+
+  /* Run the exc demuxer which should call the server function above.
+     That function returns 0 if the exception was expected.  */
+  switch (_hurdsig_fault_exc_server (&request.head, &reply.head))
+    {
+    case KERN_SUCCESS:
+      if (reply.head.msgh_remote_port != MACH_PORT_NULL)
+	__mach_msg (&reply.head, MACH_SEND_MSG, reply.head.msgh_size,
+		    0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+      break;
+    default:
+      __mach_msg_destroy (&request.head);
+    case MIG_NO_REPLY:
+    }
+
+  _hurdsig_fault_expect_signo = 0;
+  longjmp (_hurdsig_fault_env, 1);
+}
+
+static char faultstack[1024];
+
+/* Send exceptions for the signal thread to the proc server.
+   It will forward the message on to our message port,
+   and then restore the thread's state to code which
+   does `longjmp (_hurd_sigthread_fault_env, 1)'.  */
+
+void
+_hurdsig_fault_init (void)
+{
+  error_t err;
+  struct machine_thread_state state;
+  mach_port_t sigexc;
+
+  if (err = __mach_port_allocate (__mach_task_self (),
+				  MACH_PORT_RIGHT_RECEIVE, &sigexc))
+    __libc_fatal ("hurd: Can't create receive right for signal thread exc\n");
+  if (err = __mach_port_allocate (__mach_task_self (),
+				  MACH_PORT_RIGHT_RECEIVE, &forward_sigexc))
+    __libc_fatal ("hurd: Can't create receive right for signal thread exc\n");
+
+  memset (&state, 0, sizeof state);
+  MACHINE_THREAD_STATE_SET_PC (&state, faulted);
+  MACHINE_THREAD_STATE_SET_SP (&state, faultstack, sizeof faultstack);
+
+#if 0				/* Don't confuse gdb.  */
+  __thread_set_special_port (_hurd_msgport_thread,
+			     THREAD_EXCEPTION_PORT, sigexc);
+#endif
+
+  if (err = __USEPORT
+      (PROC,
+       __proc_handle_exceptions (port,
+				 sigexc,
+				 forward_sigexc, MACH_MSG_TYPE_MAKE_SEND,
+				 MACHINE_THREAD_STATE_FLAVOR,
+				 (natural_t *) &state,
+				 MACHINE_THREAD_STATE_COUNT)))
+    __libc_fatal ("hurd: proc won't handle signal thread exceptions\n");
+}
+
diff --git a/hurd/hurdfault.h b/hurd/hurdfault.h
new file mode 100644
index 0000000..00ec905
--- /dev/null
+++ b/hurd/hurdfault.h
@@ -0,0 +1,49 @@
+/* Declarations for handling faults in the signal thread.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#ifndef _HURD_FAULT_H
+#define _HURD_FAULT_H
+
+#include <setjmp.h>
+
+/* Call this before code that might fault in the signal thread; SIGNO is
+   the signal expected to possibly arrive.  This behaves like setjmp: it
+   returns zero the first time, and returns again nonzero if the signal
+   does arrive.  */
+
+#define _hurdsig_catch_fault(signo) \
+  (_hurdsig_fault_expect_signo = (signo), setjmp (_hurdsig_fault_env))
+
+/* Call this at the end of a section protected by _hurdsig_catch_fault.  */
+
+#define _hurdsig_end_catch_fault() \
+  (_hurdsig_fault_expect_signo = 0)
+
+extern jmp_buf _hurdsig_fault_env;
+extern int _hurdsig_fault_expect_signo;
+
+/* If _hurdsig_catch_fault returns nonzero, these variables
+   contain information about the signal that arrived.  */
+
+
+
+extern long int _hurdsig_fault_sigcode;
+extern int _hurdsig_fault_sigerror;
+
+#endif	/* hurd/fault.h */
diff --git a/hurd/hurdid.c b/hurd/hurdid.c
new file mode 100644
index 0000000..6f1c977
--- /dev/null
+++ b/hurd/hurdid.c
@@ -0,0 +1,91 @@
+/* Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/id.h>
+
+struct hurd_id_data _hurd_id;
+
+
+/* Check that _hurd_id.{gen,aux} are valid and update them if not.
+   Expects _hurd_id.lock to be held and does not release it.  */
+
+error_t
+_hurd_check_ids (void)
+{
+  if (! _hurd_id.valid)
+    {
+      inline void dealloc (__typeof (_hurd_id.gen) *p)
+	{
+	  if (p->uids)
+	    {
+	      __vm_deallocate (__mach_task_self (),
+			       (vm_address_t) p->uids,
+			       p->nuids * sizeof (uid_t));
+	      p->uids = NULL;
+	    }
+	  p->nuids = 0;
+	  if (p->gids)
+	    {
+	      __vm_deallocate (__mach_task_self (),
+			       (vm_address_t) p->gids,
+			       p->ngids * sizeof (gid_t));
+	      p->gids = NULL;
+	    }
+	  p->ngids = 0;
+	}
+
+      error_t err;
+
+      dealloc (&_hurd_id.gen);
+      dealloc (&_hurd_id.aux);
+
+      if (_hurd_id.rid_auth != MACH_PORT_NULL)
+	{
+	  __mach_port_deallocate (__mach_task_self (), _hurd_id.rid_auth);
+	  _hurd_id.rid_auth = MACH_PORT_NULL;
+	}
+
+      if (err = __USEPORT (AUTH, __auth_getids
+			   (port,
+			    &_hurd_id.gen.uids, &_hurd_id.gen.nuids,
+			    &_hurd_id.aux.uids, &_hurd_id.aux.nuids,
+			    &_hurd_id.gen.gids, &_hurd_id.gen.ngids,
+			    &_hurd_id.aux.gids, &_hurd_id.aux.ngids)))
+	return err;
+
+      _hurd_id.valid = 1;
+    }
+
+  return 0;
+}
+
+static void
+init_id (void)
+{
+  __mutex_init (&_hurd_id.lock);
+  _hurd_id.valid = 0;
+  _hurd_id.rid_auth = MACH_PORT_NULL;
+  _hurd_id.gen.uids = _hurd_id.aux.uids = NULL;
+  _hurd_id.gen.nuids = _hurd_id.aux.nuids = 0;
+  _hurd_id.gen.gids = _hurd_id.aux.gids = NULL;
+  _hurd_id.gen.ngids = _hurd_id.aux.ngids = 0;
+
+  (void) &init_id;		/* Avoid "defined but not used" warning.  */
+}
+text_set_element (_hurd_preinit_hook, init_id);
diff --git a/hurd/hurdinit.c b/hurd/hurdinit.c
new file mode 100644
index 0000000..4469a17
--- /dev/null
+++ b/hurd/hurdinit.c
@@ -0,0 +1,193 @@
+/* Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <hurd.h>
+#include <hurd/port.h>
+#include "set-hooks.h"
+#include "hurdmalloc.h"		/* XXX */
+
+
+int _hurd_exec_flags;
+struct hurd_port *_hurd_ports;
+unsigned int _hurd_nports;
+mode_t _hurd_umask;
+
+void _hurd_proc_init (char **argv);
+
+DEFINE_HOOK (_hurd_subinit, (void));
+
+/* Initialize the library data structures from the
+   ints and ports passed to us by the exec server.
+
+   PORTARRAY and INTARRAY are vm_deallocate'd.  */
+
+void
+_hurd_init (int flags, char **argv,
+	    mach_port_t *portarray, size_t portarraysize,
+	    int *intarray, size_t intarraysize)
+{
+  int i;
+
+  _hurd_exec_flags = flags;
+
+  _hurd_ports = malloc (portarraysize * sizeof (*_hurd_ports));
+  if (_hurd_ports == NULL)
+    __libc_fatal ("Can't allocate _hurd_ports\n");
+  _hurd_nports = portarraysize;
+
+  /* See what ports we were passed.  */
+  for (i = 0; i < portarraysize; ++i)
+    _hurd_port_init (&_hurd_ports[i], portarray[i]);
+
+  /* When the user asks for the bootstrap port,
+     he will get the one the exec server passed us.  */
+  __task_set_special_port (__mach_task_self (), TASK_BOOTSTRAP_PORT,
+			   portarray[INIT_PORT_BOOTSTRAP]);
+
+  /* Tell the proc server we exist, if it does.  */
+  if (portarray[INIT_PORT_PROC] != MACH_PORT_NULL)
+    _hurd_proc_init (argv);
+
+  if (intarraysize > INIT_UMASK)
+    _hurd_umask = intarray[INIT_UMASK] & 0777;
+  else
+    _hurd_umask = CMASK;
+
+  /* All done with init ints and ports.  */
+  __vm_deallocate (__mach_task_self (),
+		   (vm_address_t) intarray,
+		   intarraysize * sizeof (int));
+  __vm_deallocate (__mach_task_self (),
+		   (vm_address_t) portarray,
+		   portarraysize * sizeof (mach_port_t));
+
+  if (flags & EXEC_SECURE)
+    /* XXX if secure exec, elide environment variables
+       which the library uses and could be security holes.
+       CORESERVER, COREFILE
+       */ ;
+
+  /* Call other things which want to do some initialization.  These are not
+     on the __libc_subinit hook because things there like to be able to
+     assume the availability of the POSIX.1 services we provide.  */
+  RUN_HOOK (_hurd_subinit, ());
+}
+
+#include <hurd/signal.h>
+
+/* The user can do "int _hide_arguments = 1;" to make
+   sure the arguments are never visible with `ps'.  */
+int _hide_arguments, _hide_environment;
+
+/* Hook for things which should be initialized as soon as the proc
+   server is available.  */
+DEFINE_HOOK (_hurd_proc_subinit, (void));
+
+/* Do startup handshaking with the proc server just installed in _hurd_ports.
+   Call _hurdsig_init to set up signal processing.  */
+
+void
+_hurd_proc_init (char **argv)
+{
+  mach_port_t oldmsg;
+  struct hurd_userlink ulink;
+  process_t procserver;
+
+  /* Initialize the signal code; Mach exceptions will become signals.  */
+  _hurdsig_init ();
+
+  /* The signal thread is now prepared to receive messages.
+     It is safe to give the port to the proc server.  */
+
+  procserver = _hurd_port_get (&_hurd_ports[INIT_PORT_PROC], &ulink);
+
+  /* Give the proc server our message port.  */
+  __proc_setmsgport (procserver, _hurd_msgport, &oldmsg);
+  if (oldmsg != MACH_PORT_NULL)
+    /* Deallocate the old msg port we replaced.  */
+    __mach_port_deallocate (__mach_task_self (), oldmsg);
+
+  /* Tell the proc server where our args and environment are.  */
+  __proc_set_arg_locations (procserver,
+			    _hide_arguments ? 0 : (vm_address_t) argv,
+			    _hide_environment ? 0 : (vm_address_t) __environ);
+
+  _hurd_port_free (&_hurd_ports[INIT_PORT_PROC], &ulink, procserver);
+
+  /* Initialize proc server-assisted fault recovery for the signal thread.  */
+  _hurdsig_fault_init ();
+
+  /* Call other things which want to do some initialization.  These are not
+     on the _hurd_subinit hook because things there assume that things done
+     here, like _hurd_pid, are already initialized.  */
+  RUN_HOOK (_hurd_proc_subinit, ());
+
+  if (_hurd_exec_flags & EXEC_TRACED)
+    /* This process is "traced", meaning it should stop on signals or exec.
+       We are all set up now to handle signals.  Stop ourselves, to inform
+       our parent (presumably a debugger) that the exec has completed.  */
+    _hurd_raise_signal (NULL, SIGTRAP, 0, 0);
+}
+
+/* Called when we get a message telling us to change our proc server port.  */
+
+error_t
+_hurd_setproc (process_t procserver)
+{
+  error_t err;
+  mach_port_t oldmsg;
+
+  /* Give the proc server our message port.  */
+  if (err = __proc_setmsgport (procserver, _hurd_msgport, &oldmsg))
+    return err;
+  if (oldmsg != MACH_PORT_NULL)
+    /* Deallocate the old msg port we replaced.  */
+    __mach_port_deallocate (__mach_task_self (), oldmsg);
+
+  /* Tell the proc server where our args and environment are.  */
+  if (err = __proc_set_arg_locations (procserver,
+				      /* We don't know the ARGV location.  */
+				      (vm_address_t) 0,
+				      _hide_environment ? 0 :
+				      (vm_address_t) __environ))
+    return err;
+
+  /* Those calls worked, so the port looks good.  */
+  _hurd_port_set (&_hurd_ports[INIT_PORT_PROC], procserver);
+
+  {
+    pid_t oldpgrp = _hurd_pgrp;
+
+    /* Call these functions again so they can fetch the
+       new information from the new proc server.  */
+    RUN_HOOK (_hurd_proc_subinit, ());
+
+    if (_hurd_pgrp != oldpgrp)
+      {
+	/* Run things that want notification of a pgrp change.  */
+	DECLARE_HOOK (_hurd_pgrp_changed_hook, (pid_t));
+	RUN_HOOK (_hurd_pgrp_changed_hook, (_hurd_pgrp));
+      }
+  }
+
+  return 0;
+}
diff --git a/hurd/hurdinline.c b/hurd/hurdinline.c
new file mode 100644
index 0000000..12a5be6
--- /dev/null
+++ b/hurd/hurdinline.c
@@ -0,0 +1,11 @@
+/* Include this first to avoid defining its inline functions.  */
+#include <lock-intern.h>
+
+#undef _EXTERN_INLINE
+#define _EXTERN_INLINE /* Define the real function. */
+
+#include "hurd/fd.h"
+#include "hurd/signal.h"
+#include "hurd/userlink.h"
+#include "hurd/threadvar.h"
+#include "hurd/port.h"
diff --git a/hurd/hurdintr.awk b/hurd/hurdintr.awk
new file mode 100644
index 0000000..d039409
--- /dev/null
+++ b/hurd/hurdintr.awk
@@ -0,0 +1,25 @@
+BEGIN { intr=0; wantcall=0; calls=""; }
+ 
+$1 == "/*" && $2 == "INTR" && $3 == "*/" { intr=1; }
+
+NF == 1 && $1 == "routine"	{ wantcall=1; next; }
+
+intr != 0 && wantcall == 0 && NF >= 2 && $1 == "routine" \
+  {
+    if (substr($2, length($2)-2, 1) == "(")
+      calls = calls " " substr($2, 0, length($2)-1);
+    else calls = calls " " $2;
+    intr=0;
+  }
+
+wantcall != 0 && NF >= 1 \
+  {
+    if (substr($1, length($1)-2, 1) == "(")
+      calls = calls " " substr($1, 0, length($1)-1);
+    else calls = calls " " $1;
+    intr=0;
+  }
+
+{ wantcall=0; }
+
+END { print varname " :=" calls; }
diff --git a/hurd/hurdioctl.c b/hurd/hurdioctl.c
new file mode 100644
index 0000000..5a41eb1
--- /dev/null
+++ b/hurd/hurdioctl.c
@@ -0,0 +1,264 @@
+/* ioctl commands which must be done in the C library.
+Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/fd.h>
+#include <sys/ioctl.h>
+#include <hurd/ioctl.h>
+
+
+
+/* Symbol set of ioctl handler lists.  If there are user-registered
+   handlers, one of these lists will contain them.  The other lists are
+   handlers built into the library.  */
+symbol_set_define (_hurd_ioctl_handler_lists)
+
+/* Look up REQUEST in the set of handlers.  */
+ioctl_handler_t
+_hurd_lookup_ioctl_handler (int request)
+{
+  void *const *ptr;
+  const struct ioctl_handler *h;
+
+  for (ptr = symbol_set_first_element (_hurd_ioctl_handler_lists);
+       !symbol_set_end_p (_hurd_ioctl_handler_lists, ptr);
+       ++ptr)
+    for (h = *ptr; h != NULL; h = h->next)
+      if (request >= h->first_request && request <= h->last_request)
+	return h->handler;
+
+  return NULL;
+}
+
+#include <fcntl.h>
+
+/* Find out how many bytes may be read from FD without blocking.  */
+
+static int
+fioctl (int fd,
+	int request,
+	int *arg)
+{
+  error_t err;
+
+  *(volatile int *) arg = *arg;
+
+  switch (request)
+    {
+    default:
+      err = EGRATUITOUS;
+      break;
+
+    case FIONREAD:
+      {
+	mach_msg_type_number_t navail;
+	err = HURD_DPORT_USE (fd, __io_readable (port, &navail));
+	if (!err)
+	  *arg = (int) navail;
+      }
+      break;
+
+    case FIONBIO:
+      err = HURD_DPORT_USE (fd, (*arg ?
+				 __io_set_some_openmodes :
+				 __io_clear_some_openmodes)
+			    (port, O_NONBLOCK));
+      break;
+
+    case FIOASYNC:
+      err = HURD_DPORT_USE (fd, (*arg ?
+				 __io_set_some_openmodes :
+				 __io_clear_some_openmodes)
+			    (port, O_ASYNC));
+      break;
+
+    case FIOSETOWN:
+      err = HURD_DPORT_USE (fd, __io_mod_owner (port, *arg));
+      break;
+
+    case FIOGETOWN:
+      err = HURD_DPORT_USE (fd, __io_get_owner (port, arg));
+      break;
+    }
+
+  return err ? __hurd_fail (err) : 0;
+}
+
+_HURD_HANDLE_IOCTLS (fioctl, FIOGETOWN, FIONREAD);
+
+
+static int
+fioclex (int fd,
+	 int request)
+{
+  int flag;
+
+  switch (request)
+    {
+    default:
+      return __hurd_fail (EGRATUITOUS);
+    case FIOCLEX:
+      flag = FD_CLOEXEC;
+      break;
+    case FIONCLEX:
+      flag = 0;
+      break;
+    }
+
+  return __fcntl (fd, F_SETFD, flag);
+}
+_HURD_HANDLE_IOCTLS (fioclex, FIOCLEX, FIONCLEX);
+
+#include <hurd/term.h>
+
+static void
+rectty_dtable (mach_port_t cttyid)
+{
+  int i;
+  
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&_hurd_dtable_lock);
+
+  for (i = 0; i < _hurd_dtablesize; ++i)
+    {
+      struct hurd_fd *const d = _hurd_dtable[i];
+      mach_port_t newctty;
+
+      if (d == NULL)
+	/* Nothing to do for an unused descriptor cell.  */
+	continue;
+
+      if (cttyid == MACH_PORT_NULL)
+	/* We now have no controlling tty at all.  */
+	newctty = MACH_PORT_NULL;
+      else
+	HURD_PORT_USE (&d->port,
+		       ({ mach_port_t id;
+			  /* Get the io object's cttyid port.  */
+			  if (! __term_getctty (port, &id))
+			    {
+			      if (id == cttyid && /* Is it ours?  */
+				  /* Get the ctty io port.  */
+				  __term_open_ctty (port,
+						    _hurd_pid, _hurd_pgrp,
+						    &newctty))
+				/* XXX it is our ctty but the call failed? */
+				newctty = MACH_PORT_NULL;
+			      __mach_port_deallocate
+				(__mach_task_self (), (mach_port_t) id);
+			    }
+			  else
+			    newctty = MACH_PORT_NULL;
+			  0;
+			}));
+
+      /* Install the new ctty port.  */
+      _hurd_port_set (&d->ctty, newctty);
+    }
+
+  __mutex_unlock (&_hurd_dtable_lock);
+  HURD_CRITICAL_END;
+}
+
+
+/* Called when we have received a message saying to use a new ctty ID port.  */
+
+error_t
+_hurd_setcttyid (mach_port_t cttyid)
+{
+  error_t err;
+
+  if (cttyid != MACH_PORT_NULL)
+    {
+      /* Give the new send right a user reference.
+	 This is a good way to check that it is valid.  */
+      if (err = __mach_port_mod_refs (__mach_task_self (), cttyid,
+				      MACH_PORT_RIGHT_SEND, 1))
+	return err;
+    }
+
+  /* Install the port, consuming the reference we just created.  */
+  _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], cttyid);
+
+  /* Reset all the ctty ports in all the descriptors.  */
+  __USEPORT (CTTYID, (rectty_dtable (cttyid), 0));
+
+  return 0;
+}
+
+
+/* Make FD be the controlling terminal.
+   This function is called for `ioctl (fd, TCIOSCTTY)'.  */
+
+static int
+tiocsctty (int fd,
+	   int request)		/* Always TIOCSCTTY.  */
+{
+  mach_port_t cttyid;
+  error_t err;
+
+  /* Get FD's cttyid port, unless it is already ours.  */
+  err = HURD_DPORT_USE (fd, ctty != MACH_PORT_NULL ? EADDRINUSE :
+			__term_getctty (port, &cttyid));
+  if (err == EADDRINUSE)
+    /* FD is already the ctty.  Nothing to do.  */
+    return 0;
+  else if (err)
+    return __hurd_fail (err);
+
+  /* Make it our own.  */
+  _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], cttyid);
+
+  /* Reset all the ctty ports in all the descriptors.  */
+  __USEPORT (CTTYID, (rectty_dtable (cttyid), 0));
+
+  return 0;
+}
+_HURD_HANDLE_IOCTL (tiocsctty, TIOCSCTTY);
+
+/* Dissociate from the controlling terminal.  */
+
+static int
+tiocnotty (int fd,
+	   int request)		/* Always TIOCNOTTY.  */
+{
+  mach_port_t fd_cttyid;
+  error_t err;
+
+  if (err = HURD_DPORT_USE (fd, __term_getctty (port, &fd_cttyid)))
+    return __hurd_fail (err);
+
+  if (__USEPORT (CTTYID, port != fd_cttyid))
+    err = EINVAL;
+
+  __mach_port_deallocate (__mach_task_self (), fd_cttyid);
+
+  if (err)
+    return __hurd_fail (err);
+
+  /* Clear our cttyid port cell.  */
+  _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], MACH_PORT_NULL);
+
+  /* Reset all the ctty ports in all the descriptors.  */
+				
+  __USEPORT (CTTYID, (rectty_dtable (MACH_PORT_NULL), 0));
+
+  return 0;
+}
+_HURD_HANDLE_IOCTL (tiocnotty, TIOCNOTTY);
diff --git a/hurd/hurdkill.c b/hurd/hurdkill.c
new file mode 100644
index 0000000..364b6ed
--- /dev/null
+++ b/hurd/hurdkill.c
@@ -0,0 +1,84 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <errno.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <hurd.h>
+#include <hurd/port.h>
+#include <hurd/signal.h>
+#include <hurd/msg.h>
+
+/* Send a `sig_post' RPC to process number PID.  If PID is zero,
+   send the message to all processes in the current process's process group.
+   If PID is < -1, send SIG to all processes in process group - PID.
+   SIG and REFPORT are passed along in the request message.  */
+error_t
+_hurd_sig_post (pid_t pid, int sig, mach_port_t arg_refport)
+{
+  int delivered = 0;		/* Set when we deliver any signal.  */
+  error_t err;
+  mach_port_t proc;
+  struct hurd_userlink ulink;
+
+  inline void kill_pid (pid_t pid) /* Kill one PID.  */
+    {
+      err = HURD_MSGPORT_RPC (__proc_getmsgport (proc, pid, &msgport),
+			      (refport = arg_refport, 0), 0,
+			      /* If no message port we cannot send signals.  */
+			      msgport == MACH_PORT_NULL ? EPERM :
+			      __msg_sig_post (msgport, sig, refport));
+      if (! err)
+	delivered = 1;
+    }
+
+  proc = _hurd_port_get (&_hurd_ports[INIT_PORT_PROC], &ulink);
+
+  if (pid <= 0)
+    {
+      /* Send SIG to each process in pgrp (- PID).  */
+      mach_msg_type_number_t npids = 10, i;
+      pid_t pidsbuf[10], *pids = pidsbuf;
+
+      err = __proc_getpgrppids (proc, - pid, &pids, &npids);
+      if (!err)
+	{
+	  for (i = 0; i < npids; ++i)
+	    {
+	      kill_pid (pids[i]);
+	      if (err == ESRCH)
+		/* The process died already.  Ignore it.  */
+		err = 0;
+	    }
+	  if (pids != pidsbuf)
+	    __vm_deallocate (__mach_task_self (),
+			     (vm_address_t) pids, npids * sizeof (pids[0]));
+	}
+    }
+  else
+    kill_pid (pid);
+
+  _hurd_port_free (&_hurd_ports[INIT_PORT_PROC], &ulink, proc);
+
+  /* If we delivered no signals, but ERR is clear, this must mean that
+     every kill_pid call failed with ESRCH, meaning all the processes in
+     the pgrp died between proc_getpgrppids and kill_pid; in that case we
+     fail with ESRCH.  */
+  return delivered ? 0 : err ?: ESRCH;
+}
+weak_alias (_hurd_sig_post, hurd_sig_post)
diff --git a/hurd/hurdlookup.c b/hurd/hurdlookup.c
new file mode 100644
index 0000000..b467404
--- /dev/null
+++ b/hurd/hurdlookup.c
@@ -0,0 +1,381 @@
+/* Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <string.h>
+#include <limits.h>
+#include <fcntl.h>
+#include "stdio/_itoa.h"
+#include <hurd/term.h>
+
+
+/* Translate the error from dir_lookup into the error the user sees.  */
+static inline error_t
+lookup_error (error_t error)
+{
+  switch (error)
+    {
+    case EOPNOTSUPP:
+    case MIG_BAD_ID:
+      /* These indicate that the server does not understand dir_lookup
+	 at all.  If it were a directory, it would, by definition.  */
+      return ENOTDIR;
+    default:
+      return error;
+    }
+}
+
+error_t
+__hurd_file_name_lookup (file_t crdir, file_t cwdir,
+			 const char *file_name, int flags, mode_t mode,
+			 file_t *result)
+{
+  error_t err;
+  enum retry_type doretry;
+  char retryname[1024];		/* XXX string_t LOSES! */
+  file_t startdir;
+
+  startdir = file_name[0] == '/' ? crdir : cwdir;
+
+  while (file_name[0] == '/')
+    file_name++;
+
+  if (err = __dir_lookup (startdir, file_name, flags, mode,
+			  &doretry, retryname, result))
+    return lookup_error (err);
+
+  return __hurd_file_name_lookup_retry (crdir, doretry, retryname, flags, mode,
+					result);
+}
+weak_alias (__hurd_file_name_lookup, hurd_file_name_lookup)
+
+error_t
+__hurd_file_name_lookup_retry (file_t crdir,
+			       enum retry_type doretry,
+			       char retryname[1024],
+			       int flags, mode_t mode,
+			       file_t *result)
+{
+  error_t err;
+  file_t startdir;
+  file_t newpt;
+  char *file_name;
+  int dealloc_dir;
+  int nloops;
+
+  dealloc_dir = 0;
+  nloops = 0;
+  err = 0;
+  
+  while (1)
+    {
+      if (dealloc_dir)
+	__mach_port_deallocate (__mach_task_self (), startdir);
+      if (err)
+	return lookup_error (err);
+
+      switch (doretry)
+	{
+	case FS_RETRY_REAUTH:
+	  {
+	    mach_port_t ref = __mach_reply_port ();
+	    err = __io_reauthenticate (*result,
+				       ref, MACH_MSG_TYPE_MAKE_SEND);
+	    if (! err)
+	      err = __USEPORT
+		(AUTH, __auth_user_authenticate (port, *result,
+						 ref,
+						 MACH_MSG_TYPE_MAKE_SEND,
+						 &newpt));
+	    __mach_port_destroy (__mach_task_self (), ref);
+	  }
+	  __mach_port_deallocate (__mach_task_self (), *result);
+	  if (err)
+	    return err;
+	  *result = newpt;
+	  /* Fall through.  */
+
+	case FS_RETRY_NORMAL:
+#ifdef SYMLOOP_MAX
+	  if (nloops++ >= SYMLOOP_MAX)
+	    return ELOOP;
+#endif
+
+	  /* An empty RETRYNAME indicates we have the final port.  */
+	  if (retryname[0] == '\0')
+	    {
+	      /* We got a successful translation.  Now apply any open-time
+		 action flags we were passed.  */
+	      if (flags & O_EXLOCK)
+		;		/* XXX */
+	      if (!err && (flags & O_SHLOCK))
+		;		/* XXX */
+	      if (!err && (flags & O_TRUNC))
+		err = __file_truncate (*result, 0);
+
+	      if (err)
+		__mach_port_deallocate (__mach_task_self (), *result);
+	      return err;
+	    }
+
+	  startdir = *result;
+	  dealloc_dir = 1;
+	  file_name = retryname;
+	  break;
+
+	case FS_RETRY_MAGICAL:
+	  switch (retryname[0])
+	    {
+	    case '/':
+	      startdir = crdir;
+	      dealloc_dir = 0;
+	      if (*result != MACH_PORT_NULL)
+		__mach_port_deallocate (__mach_task_self (), *result);
+	      file_name = &retryname[1];
+	      break;
+
+	    case 'f':
+	      if (retryname[1] == 'd' && retryname[2] == '/')
+		{
+		  int fd;
+		  char *end;
+		  int save = errno;
+		  errno = 0;
+		  fd = (int) strtol (retryname, &end, 10);
+		  if (end == NULL || errno || /* Malformed number.  */
+		      /* Check for excess text after the number.  A slash
+			 is valid; it ends the component.  Anything else
+			 does not name a numeric file descriptor.  */
+		      (*end != '/' && *end != '\0'))
+		    {
+		      errno = save;
+		      return ENOENT;
+		    }
+		  *result = __getdport (fd);
+		  if (*result == MACH_PORT_NULL)
+		    {
+		      /* If the name was a proper number, but the file
+			 descriptor does not exist, we return EBADF instead
+			 of ENOENT.  */
+		      error_t err = errno;
+		      errno = save;
+		      return err;
+		    }
+		  errno = save;
+		  if (*end == '\0')
+		    return 0;
+		  else
+		    {
+		      /* Do a normal retry on the remaining components.  */
+		      startdir = *result;
+		      dealloc_dir = 1;
+		      file_name = end + 1; /* Skip the slash.  */
+		      break;
+		    }
+		}
+	      else
+		goto bad_magic;
+	      break;
+
+	    case 'm':
+	      if (retryname[1] == 'a' && retryname[2] == 'c' &&
+		  retryname[3] == 'h' && retryname[4] == 't' &&
+		  retryname[5] == 'y' && retryname[6] == 'p' &&
+		  retryname[7] == 'e')
+		{
+		  error_t err;
+		  struct host_basic_info hostinfo;
+		  mach_msg_type_number_t hostinfocnt = HOST_BASIC_INFO_COUNT;
+		  char *p;
+		  if (err = __host_info (__mach_host_self (), HOST_BASIC_INFO,
+					 (natural_t *) &hostinfo,
+					 &hostinfocnt))
+		    return err;
+		  if (hostinfocnt != HOST_BASIC_INFO_COUNT)
+		    return EGRATUITOUS;
+		  p = _itoa (hostinfo.cpu_subtype, &retryname[8], 10, 0);
+		  *--p = '/';
+		  p = _itoa (hostinfo.cpu_type, &retryname[8], 10, 0);
+		  if (p < retryname)
+		    abort ();	/* XXX write this right if this ever happens */
+		  if (p > retryname)
+		    strcpy (retryname, p);
+		  startdir = *result;
+		  dealloc_dir = 1;
+		}
+	      else
+		goto bad_magic;
+	      break;
+
+	    case 't':
+	      if (retryname[1] == 't' && retryname[2] == 'y')
+		switch (retryname[3])
+		  {
+		    error_t opentty (file_t *result)
+		      {
+			error_t err;
+			file_t unauth;
+			err = __USEPORT (CTTYID,
+					 __termctty_open_terminal (port,
+								   flags,
+								   &unauth));
+			if (! err)
+			  {
+			    mach_port_t ref = __mach_reply_port ();
+			    err = __io_reauthenticate
+			      (unauth,
+			       ref,
+			       MACH_MSG_TYPE_MAKE_SEND);
+			    if (! err)
+			      err = __USEPORT
+				(AUTH, __auth_user_authenticate
+				 (port,
+				  unauth,
+				  ref, MACH_MSG_TYPE_MAKE_SEND,
+				  result));
+			    __mach_port_deallocate (__mach_task_self (),
+						    unauth);
+			    __mach_port_destroy (__mach_task_self (), ref);
+			  }
+			return err;
+		      }
+
+		  case '\0':
+		    return opentty (result);
+		  case '/':
+		    if (err = opentty (&startdir))
+		      return err;
+		    dealloc_dir = 1;
+		    strcpy (retryname, &retryname[4]);
+		    break;
+		  default:
+		    goto bad_magic;
+		  }
+	      else
+		goto bad_magic;
+	      break;
+
+	    default:
+	    bad_magic:
+	      return EGRATUITOUS;
+	    }
+	  break;		
+
+	default:
+	  return EGRATUITOUS;
+	}
+
+      err = __dir_lookup (startdir, file_name, flags, mode,
+			  &doretry, retryname, result);
+    }
+}
+weak_alias (__hurd_file_name_lookup_retry, hurd_file_name_lookup_retry)
+
+error_t
+__hurd_file_name_split (file_t crdir, file_t cwdir,
+			const char *file_name,
+			file_t *dir, char **name)
+{
+  const char *lastslash;
+  error_t err;
+
+  lastslash = strrchr (file_name, '/');
+  if (lastslash != NULL)
+    {
+      if (lastslash == file_name)
+	{
+	  /* "/foobar" => crdir + "foobar".  */
+	  *name = (char *) file_name + 1;
+	  if (err = __mach_port_mod_refs (__mach_task_self (), 
+					  crdir, MACH_PORT_RIGHT_SEND, +1))
+	    return err;
+	  *dir = crdir;
+	  return 0;
+	}
+      else
+	{
+	  /* "/dir1/dir2/.../file".  */
+	  char dirname[lastslash - file_name + 1];
+	  memcpy (dirname, file_name, lastslash - file_name);
+	  dirname[lastslash - file_name] = '\0';
+	  *name = (char *) lastslash + 1;
+	  return __hurd_file_name_lookup (crdir, cwdir, dirname, 0, 0, dir);
+	}
+    }
+  else
+    {
+      /* "foobar" => cwdir + "foobar".  */
+      *name = (char *) file_name;
+      if (err = __mach_port_mod_refs (__mach_task_self (),
+				      cwdir, MACH_PORT_RIGHT_SEND, +1))
+	return err;
+      *dir = cwdir;
+      return 0;
+    }
+}
+weak_alias (__hurd_file_name_split, hurd_file_name_split)
+
+
+file_t
+__file_name_lookup (const char *file_name, int flags, mode_t mode)
+{
+  error_t err;
+  file_t result, crdir, cwdir;
+  struct hurd_userlink crdir_ulink, cwdir_ulink;
+
+  crdir = _hurd_port_get (&_hurd_ports[INIT_PORT_CRDIR], &crdir_ulink);
+  cwdir = _hurd_port_get (&_hurd_ports[INIT_PORT_CWDIR], &cwdir_ulink);
+
+  err = __hurd_file_name_lookup (crdir, cwdir, file_name, flags, mode,
+				 &result);
+
+  _hurd_port_free (&_hurd_ports[INIT_PORT_CRDIR], &crdir_ulink, crdir);
+  _hurd_port_free (&_hurd_ports[INIT_PORT_CWDIR], &cwdir_ulink, cwdir);
+
+  if (err)
+    return __hurd_fail (err), MACH_PORT_NULL;
+  else
+    return result;
+}
+weak_alias (__file_name_lookup, file_name_lookup)
+
+
+file_t
+__file_name_split (const char *file_name, char **name)
+{
+  error_t err;
+  file_t dir, crdir, cwdir;
+  struct hurd_userlink crdir_ulink, cwdir_ulink;
+
+  crdir = _hurd_port_get (&_hurd_ports[INIT_PORT_CRDIR], &crdir_ulink);
+  cwdir = _hurd_port_get (&_hurd_ports[INIT_PORT_CWDIR], &cwdir_ulink);
+
+  err = __hurd_file_name_split (crdir, cwdir, file_name, &dir, name);
+
+  _hurd_port_free (&_hurd_ports[INIT_PORT_CRDIR], &crdir_ulink, crdir);
+  _hurd_port_free (&_hurd_ports[INIT_PORT_CWDIR], &cwdir_ulink, cwdir);
+
+  if (err)
+    {
+      errno = err;
+      return MACH_PORT_NULL;
+    }
+  else
+    return dir;
+}
+weak_alias (__file_name_split, file_name_split)
diff --git a/hurd/hurdmalloc.c b/hurd/hurdmalloc.c
new file mode 100644
index 0000000..1de887b
--- /dev/null
+++ b/hurd/hurdmalloc.c
@@ -0,0 +1,411 @@
+#include <stdlib.h>
+#include <string.h>
+
+#define bcopy(s,d,n)	memcpy ((d), (s), (n)) /* No overlap handling.  */
+
+#include "hurdmalloc.h"		/* XXX see that file */
+
+#include <mach.h>
+#define vm_allocate __vm_allocate
+#define vm_page_size __vm_page_size
+
+/* 
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ * HISTORY
+ * $Log$
+ * Revision 1.10  1995/02/13 22:04:34  roland
+ * (malloc_init): Add self reference to avoid not only the `defined but not
+ * used' warning, but also to avoid GCC optimizing out the entire function
+ * (!).
+ *
+ * Revision 1.9  1995/02/13  16:36:08  roland
+ * Include string.h; #define bcopy using memcpy.
+ *
+ * Revision 1.8  1995/02/03  01:54:21  roland
+ * Remove bogus bcopy decl.
+ *
+ * Revision 1.7  1995/01/26  04:22:02  roland
+ * Don't include gnu-stabs.h.
+ *
+ * Revision 1.6  1994/12/07  19:41:26  roland
+ * (vm_allocate, vm_page_size): #define these to __ names at top.
+ *
+ * Revision 1.5  1994/06/04  01:48:44  roland
+ * entered into RCS
+ *
+ * Revision 2.7  91/05/14  17:57:34  mrt
+ * 	Correcting copyright
+ * 
+ * Revision 2.6  91/02/14  14:20:26  mrt
+ * 	Added new Mach copyright
+ * 	[91/02/13  12:41:21  mrt]
+ * 
+ * Revision 2.5  90/11/05  14:37:33  rpd
+ * 	Added malloc_fork* code.
+ * 	[90/11/02            rwd]
+ * 
+ * 	Add spin_lock_t.
+ * 	[90/10/31            rwd]
+ * 
+ * Revision 2.4  90/08/07  14:31:28  rpd
+ * 	Removed RCS keyword nonsense.
+ * 
+ * Revision 2.3  90/06/02  15:14:00  rpd
+ * 	Converted to new IPC.
+ * 	[90/03/20  20:56:57  rpd]
+ * 
+ * Revision 2.2  89/12/08  19:53:59  rwd
+ * 	Removed conditionals.
+ * 	[89/10/23            rwd]
+ * 
+ * Revision 2.1  89/08/03  17:09:46  rwd
+ * Created.
+ * 
+ *
+ * 13-Sep-88  Eric Cooper (ecc) at Carnegie Mellon University
+ *	Changed realloc() to copy min(old size, new size) bytes.
+ *	Bug found by Mike Kupfer at Olivetti.
+ */
+/*
+ * 	File: 	malloc.c
+ *	Author: Eric Cooper, Carnegie Mellon University
+ *	Date:	July, 1988
+ *
+ * 	Memory allocator for use with multiple threads.
+ */
+
+
+#include <cthreads.h>
+#include "cthread_internals.h"
+
+
+/*
+ * Structure of memory block header.
+ * When free, next points to next block on free list.
+ * When allocated, fl points to free list.
+ * Size of header is 4 bytes, so minimum usable block size is 8 bytes.
+ */
+typedef union header {
+	union header *next;
+	struct free_list *fl;
+} *header_t;
+
+#define MIN_SIZE	8	/* minimum block size */
+
+typedef struct free_list {
+	spin_lock_t lock;	/* spin lock for mutual exclusion */
+	header_t head;		/* head of free list for this size */
+#ifdef	DEBUG
+	int in_use;		/* # mallocs - # frees */
+#endif	DEBUG
+} *free_list_t;
+
+/*
+ * Free list with index i contains blocks of size 2^(i+3) including header.
+ * Smallest block size is 8, with 4 bytes available to user.
+ * Size argument to malloc is a signed integer for sanity checking,
+ * so largest block size is 2^31.
+ */
+#define NBUCKETS	29
+
+static struct free_list malloc_free_list[NBUCKETS];
+
+/* Initialization just sets everything to zero, but might be necessary on a
+   machine where spin_lock_init does otherwise, and is necessary when
+   running an executable that was written by something like Emacs's unexec.
+   It preserves the values of data variables like malloc_free_list, but
+   does not save the vm_allocate'd space allocated by this malloc.  */
+
+static void
+malloc_init (void)
+{
+  int i;
+  for (i = 0; i < NBUCKETS; ++i)
+    {
+      spin_lock_init (&malloc_free_list[i].lock);
+      malloc_free_list[i].head = NULL;
+#ifdef DEBUG
+      malloc_free_list[i].in_use = 0;
+#endif
+    }
+
+  /* This not only suppresses a `defined but not used' warning,
+     but it is ABSOLUTELY NECESSARY to avoid the hyperclever
+     compiler from "optimizing out" the entire function!  */
+  (void) &malloc_init;
+}
+
+static void
+more_memory(size, fl)
+	int size;
+	register free_list_t fl;
+{
+	register int amount;
+	register int n;
+	vm_address_t where;
+	register header_t h;
+	kern_return_t r;
+
+	if (size <= vm_page_size) {
+		amount = vm_page_size;
+		n = vm_page_size / size;
+		/*
+		 * We lose vm_page_size - n*size bytes here.  */
+	} else {
+		amount = size;
+		n = 1;
+	}
+	MACH_CALL(vm_allocate(mach_task_self(), &where, (vm_size_t) amount, TRUE), r);
+	h = (header_t) where;
+	do {
+	  h->next = fl->head;
+	  fl->head = h;
+	  h = (header_t) ((char *) h + size);
+	} while (--n != 0);
+}
+
+/* Declaration changed to standard one for GNU.  */
+void *
+malloc(size)
+	register size_t size;
+{
+	register int i, n;
+	register free_list_t fl;
+	register header_t h;
+
+	if ((int) size < 0)		/* sanity check */
+		return 0;
+	size += sizeof(union header);
+	/*
+	 * Find smallest power-of-two block size
+	 * big enough to hold requested size plus header.
+	 */
+	i = 0;
+	n = MIN_SIZE;
+	while (n < size) {
+		i += 1;
+		n <<= 1;
+	}
+	ASSERT(i < NBUCKETS);
+	fl = &malloc_free_list[i];
+	spin_lock(&fl->lock);
+	h = fl->head;
+	if (h == 0) {
+		/*
+		 * Free list is empty;
+		 * allocate more blocks.
+		 */
+		more_memory(n, fl);
+		h = fl->head;
+		if (h == 0) {
+			/*
+			 * Allocation failed.
+			 */
+			spin_unlock(&fl->lock);
+			return 0;
+		}
+	}
+	/*
+	 * Pop block from free list.
+	 */
+	fl->head = h->next;
+#ifdef	DEBUG
+	fl->in_use += 1;
+#endif	DEBUG
+	spin_unlock(&fl->lock);
+	/*
+	 * Store free list pointer in block header
+	 * so we can figure out where it goes
+	 * at free() time.
+	 */
+	h->fl = fl;
+	/*
+	 * Return pointer past the block header.
+	 */
+	return ((char *) h) + sizeof(union header);
+}
+
+/* Declaration changed to standard one for GNU.  */
+void
+free(base)
+	void *base;
+{
+	register header_t h;
+	register free_list_t fl;
+	register int i;
+
+	if (base == 0)
+		return;
+	/*
+	 * Find free list for block.
+	 */
+	h = (header_t) (base - sizeof(union header));
+	fl = h->fl;
+	i = fl - malloc_free_list;
+	/*
+	 * Sanity checks.
+	 */
+	if (i < 0 || i >= NBUCKETS) {
+		ASSERT(0 <= i && i < NBUCKETS);
+		return;
+	}
+	if (fl != &malloc_free_list[i]) {
+		ASSERT(fl == &malloc_free_list[i]);
+		return;
+	}
+	/*
+	 * Push block on free list.
+	 */
+	spin_lock(&fl->lock);
+	h->next = fl->head;
+	fl->head = h;
+#ifdef	DEBUG
+	fl->in_use -= 1;
+#endif	DEBUG
+	spin_unlock(&fl->lock);
+	return;
+}
+
+/* Declaration changed to standard one for GNU.  */
+void *
+realloc(old_base, new_size)
+        void *old_base;
+        size_t new_size;
+{
+	register header_t h;
+	register free_list_t fl;
+	register int i;
+	unsigned int old_size;
+	char *new_base;
+
+	if (old_base == 0)
+	  return malloc (new_size);
+
+	/*
+	 * Find size of old block.
+	 */
+	h = (header_t) (old_base - sizeof(union header));
+	fl = h->fl;
+	i = fl - malloc_free_list;
+	/*
+	 * Sanity checks.
+	 */
+	if (i < 0 || i >= NBUCKETS) {
+		ASSERT(0 <= i && i < NBUCKETS);
+		return 0;
+	}
+	if (fl != &malloc_free_list[i]) {
+		ASSERT(fl == &malloc_free_list[i]);
+		return 0;
+	}
+	/*
+	 * Free list with index i contains blocks of size 2^(i+3) including header.
+	 */
+	old_size = (1 << (i+3)) - sizeof(union header);
+	/*
+	 * Allocate new block, copy old bytes, and free old block.
+	 */
+	new_base = malloc(new_size);
+	if (new_base != 0)
+		bcopy(old_base, new_base, (int) (old_size < new_size ? old_size : new_size));
+	free(old_base);
+	return new_base;
+}
+
+#ifdef	DEBUG
+void
+print_malloc_free_list()
+{
+  	register int i, size;
+	register free_list_t fl;
+	register int n;
+  	register header_t h;
+	int total_used = 0;
+	int total_free = 0;
+
+	fprintf(stderr, "      Size     In Use       Free      Total\n");
+  	for (i = 0, size = MIN_SIZE, fl = malloc_free_list;
+	     i < NBUCKETS;
+	     i += 1, size <<= 1, fl += 1) {
+		spin_lock(&fl->lock);
+		if (fl->in_use != 0 || fl->head != 0) {
+			total_used += fl->in_use * size;
+			for (n = 0, h = fl->head; h != 0; h = h->next, n += 1)
+				;
+			total_free += n * size;
+			fprintf(stderr, "%10d %10d %10d %10d\n",
+				size, fl->in_use, n, fl->in_use + n);
+		}
+		spin_unlock(&fl->lock);
+  	}
+  	fprintf(stderr, " all sizes %10d %10d %10d\n",
+		total_used, total_free, total_used + total_free);
+}
+#endif	DEBUG
+
+static void malloc_fork_prepare()
+/*
+ * Prepare the malloc module for a fork by insuring that no thread is in a
+ * malloc critical section.
+ */
+{
+    register int i;
+    
+    for (i = 0; i < NBUCKETS; i++) {
+	spin_lock(&malloc_free_list[i].lock);
+    }
+}
+
+static void malloc_fork_parent()
+/*
+ * Called in the parent process after a fork() to resume normal operation.
+ */
+{
+    register int i;
+
+    for (i = NBUCKETS-1; i >= 0; i--) {
+	spin_unlock(&malloc_free_list[i].lock);
+    }
+}
+
+static void malloc_fork_child()
+/*
+ * Called in the child process after a fork() to resume normal operation.
+ */
+{
+    register int i;
+
+    for (i = NBUCKETS-1; i >= 0; i--) {
+	spin_unlock(&malloc_free_list[i].lock);
+    }
+}
+
+
+text_set_element (_hurd_fork_prepare_hook, malloc_fork_prepare);
+text_set_element (_hurd_fork_parent_hook, malloc_fork_parent);
+text_set_element (_hurd_fork_child_hook, malloc_fork_child);
+text_set_element (_hurd_preinit_hook, malloc_init);
diff --git a/hurd/hurdmalloc.h b/hurd/hurdmalloc.h
new file mode 100644
index 0000000..9128609
--- /dev/null
+++ b/hurd/hurdmalloc.h
@@ -0,0 +1,17 @@
+/* XXX this file is a tempoary hack.
+
+   All hurd-internal code which uses malloc et al includes this file so it
+   will use the internal malloc routines _hurd_{malloc,realloc,free}
+   instead.  The "hurd-internal" functions are the cthreads version,
+   which uses vm_allocate and is thread-safe.  The normal user version
+   of malloc et al is the unixoid one using sbrk.
+
+ */
+
+extern void *_hurd_malloc (size_t);
+extern void *_hurd_realloc (void *, size_t);
+extern void _hurd_free (void *);
+
+#define malloc	_hurd_malloc
+#define realloc	_hurd_realloc
+#define free	_hurd_free
diff --git a/hurd/hurdmsg.c b/hurd/hurdmsg.c
new file mode 100644
index 0000000..57b6b8d
--- /dev/null
+++ b/hurd/hurdmsg.c
@@ -0,0 +1,451 @@
+/* Copyright (C) 1992, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/msg_server.h>
+#include <hurd/fd.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+
+
+#define AUTHCHECK \
+  if (auth != mach_task_self () && ! __USEPORT (AUTH, port == auth)) \
+    return EPERM
+
+
+/* Snarfing and frobbing the init ports.  */
+
+kern_return_t
+_S_msg_get_init_port (mach_port_t msgport, mach_port_t auth, int which,
+		  mach_port_t *result, mach_msg_type_name_t *result_type)
+{
+  AUTHCHECK;
+  *result_type = MACH_MSG_TYPE_MOVE_SEND;
+  /* This function adds a new user reference for the *RESULT it gives back.
+     Our reply message uses a move-send right that consumes this reference.  */
+  return _hurd_ports_get (which, result);
+}
+
+kern_return_t
+_S_msg_set_init_port (mach_port_t msgport, mach_port_t auth,
+		  int which, mach_port_t port)
+{
+  error_t err;
+
+  AUTHCHECK;
+
+  err = _hurd_ports_set (which, port);
+  if (err == 0)
+    __mach_port_deallocate (__mach_task_self (), port);
+
+  return 0;
+}
+
+kern_return_t
+_S_msg_get_init_ports (mach_port_t msgport, mach_port_t auth,
+		   mach_port_t **ports,
+		   mach_msg_type_name_t *ports_type,
+		   mach_msg_type_number_t *nports)
+{
+  mach_msg_type_number_t i;
+  error_t err;
+
+  AUTHCHECK;
+
+  if (err = __vm_allocate (__mach_task_self (), (vm_address_t *) ports,
+			   _hurd_nports * sizeof (mach_port_t), 1))
+    return err;
+  *nports = _hurd_nports;
+
+  for (i = 0; i < _hurd_nports; ++i)
+    /* This function adds a new user ref for the *RESULT it gives back.
+       Our reply message uses move-send rights that consumes this ref.  */
+    if (err = _hurd_ports_get (i, &(*ports)[i]))
+      {
+	/* Died part way through.  Deallocate the ports already fetched.  */
+	while (i-- > 0)
+	  __mach_port_deallocate (__mach_task_self (), (*ports)[i]);
+	__vm_deallocate (__mach_task_self (),
+			 (vm_address_t) *ports,
+			 *nports * sizeof (mach_port_t));
+	return err;
+      }
+
+  *ports_type = MACH_MSG_TYPE_MOVE_SEND;
+  return 0;
+}
+
+kern_return_t
+_S_msg_set_init_ports (mach_port_t msgport, mach_port_t auth,
+		   mach_port_t *ports, mach_msg_type_number_t nports)
+{
+  mach_msg_type_number_t i;
+  error_t err;
+
+  AUTHCHECK;
+
+  for (i = 0; i < _hurd_nports; ++i)
+    {
+      if (err = _hurd_ports_set (i, ports[i]))
+	return err;
+      else
+	__mach_port_deallocate (__mach_task_self (), ports[i]);
+    }
+
+  return 0;
+}
+
+/* Snarfing and frobbing the init ints.  */
+
+static kern_return_t
+get_int (int which, int *value)
+{
+  switch (which)
+    {
+    case INIT_UMASK:
+      *value = _hurd_umask;
+      return 0;
+    case INIT_SIGMASK:
+      {
+	struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
+	__spin_lock (&ss->lock);
+	*value = ss->blocked;
+	__spin_unlock (&ss->lock);
+	return 0;
+      }
+    case INIT_SIGPENDING:
+      {
+	struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
+	__spin_lock (&ss->lock);
+	*value = ss->pending;
+	__spin_unlock (&ss->lock);
+	return 0;
+      }
+    case INIT_SIGIGN:
+      {
+	struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
+	sigset_t ign;
+	int sig;
+	__spin_lock (&ss->lock);
+	__sigemptyset (&ign);
+	for (sig = 1; sig < NSIG; ++sig)
+	  if (ss->actions[sig].sa_handler == SIG_IGN)
+	    __sigaddset (&ign, sig);
+	__spin_unlock (&ss->lock);
+	*value = ign;
+	return 0;
+      }
+    default:
+      return EINVAL;
+    }
+}
+
+kern_return_t
+_S_msg_get_init_int (mach_port_t msgport, mach_port_t auth,
+		 int which, int *value)
+{
+  AUTHCHECK;
+
+  return get_int (which, value);
+}
+
+kern_return_t
+_S_msg_get_init_ints (mach_port_t msgport, mach_port_t auth,
+		  int **values, mach_msg_type_number_t *nvalues)
+{
+  error_t err;
+  mach_msg_type_number_t i;
+
+  AUTHCHECK;
+
+  if (err = __vm_allocate (__mach_task_self (), (vm_address_t *) values,
+			   INIT_INT_MAX * sizeof (int), 1))
+    return err;
+  *nvalues = INIT_INT_MAX;
+
+  for (i = 0; i < INIT_INT_MAX; ++i)
+    switch (err = get_int (i, &(*values)[i]))
+      {
+      case 0:			/* Success.  */
+	break;
+      case EINVAL:		/* Unknown index.  */
+	(*values)[i] = 0;
+	break;
+      default:			/* Lossage.  */
+	__vm_deallocate (__mach_task_self (),
+			 (vm_address_t) *values, INIT_INT_MAX * sizeof (int));
+	return err;
+      }
+
+  return 0;
+}
+
+
+static kern_return_t
+set_int (int which, int value)
+{
+  switch (which)
+    {
+    case INIT_UMASK:
+      _hurd_umask = value;
+      return 0;
+
+      /* These are pretty odd things to do.  But you asked for it.  */
+    case INIT_SIGMASK:
+      {
+	struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
+	__spin_lock (&ss->lock);
+	ss->blocked = value;
+	__spin_unlock (&ss->lock);
+	return 0;
+      }
+    case INIT_SIGPENDING:
+      {
+	struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
+	__spin_lock (&ss->lock);
+	ss->pending = value;
+	__spin_unlock (&ss->lock);
+	return 0;
+      }
+    case INIT_SIGIGN:
+      {
+	struct hurd_sigstate *ss = _hurd_thread_sigstate (_hurd_sigthread);
+	int sig;
+	const sigset_t ign = value;
+	__spin_lock (&ss->lock);
+	for (sig = 1; sig < NSIG; ++sig)
+	  {
+	    if (__sigismember (&ign, sig))
+	      ss->actions[sig].sa_handler = SIG_IGN;
+	    else if (ss->actions[sig].sa_handler == SIG_IGN)
+	      ss->actions[sig].sa_handler = SIG_DFL;
+	  }
+	__spin_unlock (&ss->lock);
+	return 0;
+      }
+    default:
+      return EINVAL;
+    }
+}
+
+kern_return_t
+_S_msg_set_init_int (mach_port_t msgport, mach_port_t auth,
+		 int which, int value)
+{
+  AUTHCHECK;
+
+  return set_int (which, value);
+}
+
+kern_return_t
+_S_msg_set_init_ints (mach_port_t msgport, mach_port_t auth,
+		  int *values, mach_msg_type_number_t nvalues)
+{
+  error_t err;
+  mach_msg_type_number_t i;
+
+  AUTHCHECK;
+
+  for (i = 0; i < INIT_INT_MAX; ++i)
+    switch (err = set_int (i, values[i]))
+      {
+      case 0:			/* Success.  */
+	break;
+      case EINVAL:		/* Unknown index.  */
+	break;
+      default:			/* Lossage.  */
+	return err;
+      }
+
+  return 0;
+}
+
+
+kern_return_t
+_S_msg_get_fd (mach_port_t msgport, mach_port_t auth,
+	   int which, mach_port_t *result, mach_msg_type_name_t *result_type)
+{
+  AUTHCHECK;
+
+  /* This creates a new user reference for the send right.
+     Our reply message will move that reference to the caller.  */
+  *result = __getdport (which);
+  if (*result == MACH_PORT_NULL)
+    return errno;
+  *result_type = MACH_MSG_TYPE_MOVE_SEND;
+
+  return 0;
+}
+
+kern_return_t
+_S_msg_set_fd (mach_port_t msgport, mach_port_t auth,
+	   int which, mach_port_t port)
+{
+  AUTHCHECK;
+
+  /* We consume the reference if successful.  */
+  return HURD_FD_USE (which, (_hurd_port2fd (descriptor, port, 0), 0));
+}
+
+/* Snarfing and frobbing environment variables.  */
+
+kern_return_t
+_S_msg_get_env_variable (mach_port_t msgport,
+		     char *variable,
+		     char **data, mach_msg_type_number_t *datalen)
+{
+  const char *value = getenv (variable);
+
+  if (value == NULL)
+    return ENOENT;
+
+  /* XXX this pointer might become invalid */
+  *data = value;
+  *datalen = strlen (value);
+  return 0;
+}
+
+
+kern_return_t
+_S_msg_set_env_variable (mach_port_t msgport, mach_port_t auth,
+		     char *variable,
+		     char *value,
+		     int replace)
+{
+  AUTHCHECK;
+
+  if (setenv (variable, value, replace)) /* XXX name space */
+    return errno;
+  return 0;
+}
+
+kern_return_t
+_S_msg_get_environment (mach_port_t msgport,
+		    char **data, mach_msg_type_number_t *datalen)
+{
+  /* Pack the environment into an array with nulls separating elements.  */
+  if (__environ != NULL)
+    {
+      char *ap, **p;
+      size_t envlen = 0;
+
+      for (p = __environ; *p != NULL; ++p)
+	envlen += strlen (*p) + 1;
+
+      if (envlen > *datalen)
+	{
+	  if (__vm_allocate (__mach_task_self (),
+			     (vm_address_t *) data, envlen, 1))
+	    return ENOMEM;
+	}
+
+      ap = *data;
+      for (p = __environ; *p != NULL; ++p)
+	ap = __memccpy (ap, *p, '\0', ULONG_MAX);
+
+      *datalen = envlen;
+    }
+  else
+    *datalen = 0;
+
+  return 0;
+}
+
+kern_return_t
+_S_msg_set_environment (mach_port_t msgport, mach_port_t auth,
+		    char *data, mach_msg_type_number_t datalen)
+{
+  int _hurd_split_args (char *, mach_msg_type_number_t, char **);
+  int envc;
+  char **envp;
+
+  AUTHCHECK;
+
+  envc = _hurd_split_args (data, datalen, NULL);
+  envp = malloc ((envc + 1) * sizeof (char *));
+  if (envp == NULL)
+    return errno;
+  _hurd_split_args (data, datalen, envp);
+  __environ = envp;		/* XXX cooperate with loadenv et al */
+  return 0;
+}
+
+/* Get and frob the exec flags.  */
+
+kern_return_t
+_S_msg_get_exec_flags (mach_port_t process, mach_port_t auth,
+		       int *flags)
+{
+  AUTHCHECK;
+
+  *flags = _hurd_exec_flags;
+  return 0;
+}
+
+kern_return_t
+_S_msg_set_all_exec_flags (mach_port_t process, mach_port_t auth,
+			   int flags)
+{
+  AUTHCHECK;
+
+  _hurd_exec_flags = flags;
+  return 0;
+}
+
+kern_return_t
+_S_msg_set_some_exec_flags (mach_port_t process, mach_port_t auth,
+			    int flags)
+{
+  AUTHCHECK;
+
+  _hurd_exec_flags |= flags;
+  return 0;
+}
+
+kern_return_t
+_S_msg_clear_some_exec_flags (mach_port_t process, mach_port_t auth,
+			      int flags)
+{
+  AUTHCHECK;
+
+  _hurd_exec_flags &= ~flags;
+  return 0;
+}
+
+
+/* XXX */
+
+kern_return_t
+_S_msg_get_dtable (mach_port_t process,
+	       mach_port_t refport,
+	       portarray_t *dtable,
+	       mach_msg_type_name_t *dtablePoly,
+	       mach_msg_type_number_t *dtableCnt)
+{ return EOPNOTSUPP; }
+
+kern_return_t
+_S_msg_set_dtable (mach_port_t process,
+	       mach_port_t refport,
+	       portarray_t dtable,
+	       mach_msg_type_number_t dtableCnt)
+{ return EOPNOTSUPP; }
+
+kern_return_t
+_S_msg_startup_dosync (mach_port_t process)
+{ return EOPNOTSUPP; }
diff --git a/hurd/hurdpid.c b/hurd/hurdpid.c
new file mode 100644
index 0000000..23594d9
--- /dev/null
+++ b/hurd/hurdpid.c
@@ -0,0 +1,71 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+pid_t _hurd_pid, _hurd_ppid, _hurd_pgrp;
+int _hurd_orphaned;
+
+static void
+init_pids (void)
+{
+  __USEPORT (PROC,
+	     ({
+	       __proc_getpids (port, &_hurd_pid, &_hurd_ppid, &_hurd_orphaned);
+	       __proc_getpgrp (port, _hurd_pid, &_hurd_pgrp);
+	     }));
+
+  (void) &init_pids;		/* Avoid "defined but not used" warning.  */
+}
+
+text_set_element (_hurd_proc_subinit, init_pids);
+
+#include <hurd/msg_server.h>
+#include "set-hooks.h"
+#include <cthreads.h>
+
+DEFINE_HOOK (_hurd_pgrp_changed_hook, (pid_t));
+
+/* These let user threads synchronize with an operation which changes ids.  */
+unsigned int _hurd_pids_changed_stamp;
+struct condition _hurd_pids_changed_sync;
+
+kern_return_t
+_S_msg_proc_newids (mach_port_t me,
+		    task_t task,
+		    pid_t ppid, pid_t pgrp, int orphaned)
+{
+  if (task != __mach_task_self ())
+    return EPERM;
+
+  __mach_port_deallocate (__mach_task_self (), task);
+
+  _hurd_ppid = ppid;
+  _hurd_pgrp = pgrp;
+  _hurd_orphaned = orphaned;
+
+  /* Run things that want notification of a pgrp change.  */
+  RUN_HOOK (_hurd_pgrp_changed_hook, (_hurd_pgrp));
+
+  /* Notify any waiting user threads that the id change as been completed.  */
+  ++_hurd_pids_changed_stamp;
+#ifdef noteven
+  __condition_broadcast (&_hurd_pids_changed_sync);
+#endif
+
+  return 0;
+}
diff --git a/hurd/hurdports.c b/hurd/hurdports.c
new file mode 100644
index 0000000..5b7dfd8
--- /dev/null
+++ b/hurd/hurdports.c
@@ -0,0 +1,52 @@
+/* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/port.h>
+
+
+static inline mach_port_t
+get (const int idx)
+{
+  mach_port_t result;
+  error_t err = _hurd_ports_get (idx, &result);
+
+  if (err)
+    return __hurd_fail (err), MACH_PORT_NULL;
+  return result;
+}
+#define	GET(type, what, idx) \
+  type get##what (void) { return get (INIT_PORT_##idx); }
+
+static inline int
+set (const int idx, mach_port_t new)
+{
+  error_t err = _hurd_ports_set (idx, new);
+  return err ? __hurd_fail (err) : 0;
+}
+#define SET(type, what, idx) \
+  int set##what (type new) { return set (INIT_PORT_##idx, new); }
+
+#define	GETSET(type, what, idx) \
+  GET (type, what, idx) SET (type, what, idx)
+
+GETSET (process_t, proc, PROC)
+GETSET (mach_port_t, cttyid, CTTYID)
+GETSET (file_t, cwdir, CWDIR)
+GETSET (file_t, crdir, CRDIR)
+GETSET (auth_t, auth, AUTH)
diff --git a/hurd/hurdprio.c b/hurd/hurdprio.c
new file mode 100644
index 0000000..d7beb3c
--- /dev/null
+++ b/hurd/hurdprio.c
@@ -0,0 +1,87 @@
+/* Support code for dealing with priorities in the Hurd.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd/resource.h>
+#include <hurd.h>
+
+error_t
+_hurd_priority_which_map (enum __priority_which which, int who,
+			  error_t (*function) (pid_t, struct procinfo *))
+{
+  mach_msg_type_number_t npids = 64, i;
+  pid_t pidbuf[npids], *pids;
+  error_t err;
+  struct procinfo *pip;
+  int pibuf[sizeof *pip + 5 * sizeof (pip->threadinfos[0])], *pi = pibuf;
+  mach_msg_type_number_t pisize = sizeof (pibuf) / sizeof (int);
+
+  switch (which)
+    {
+    case PRIO_PROCESS:
+      npids = 1;
+      pids[0] = who;
+      err = 0;
+      break;
+
+    case PRIO_PGRP:
+      err = __USEPORT (PROC, __proc_getpgrppids (port, who, &pids, &npids));
+      break;
+
+    case PRIO_USER:
+      err = __USEPORT (PROC, __proc_getallpids (port, &pids, &npids));
+      break;
+
+    default:
+      return EINVAL;
+    }
+
+  for (i = 0; !err && i < npids; ++i)
+    {
+      if (which == PRIO_USER)
+	{
+	  /* Get procinfo to check the owner.  */
+	  int *oldpi = pi;
+	  mach_msg_type_number_t oldpisize = pisize;
+	  if (err = __USEPORT (PROC, __proc_getprocinfo (port, pids[i],
+							 &pi, &pisize)))
+	    continue;
+	  if (pi != oldpi && oldpi != pibuf)
+	    /* Old buffer from last call was not reused; free it.  */
+	    __vm_deallocate (__mach_task_self (),
+			     (vm_address_t) oldpi, oldpisize * sizeof pi[0]);
+
+	  pip = (struct procinfo *) pi;
+	  if (pip->owner != who)
+	    continue;
+	}
+      else
+	pip = NULL;
+
+      err = (*function) (pids[i], pip);
+    }
+
+  if (pids != pidbuf)
+    __vm_deallocate (__mach_task_self (),
+		     (vm_address_t) pids, npids * sizeof pids[0]);
+  if (pi != pibuf)
+    __vm_deallocate (__mach_task_self (),
+		     (vm_address_t) pi, pisize * sizeof pi[0]);
+
+  return err;
+}
diff --git a/hurd/hurdrlimit.c b/hurd/hurdrlimit.c
new file mode 100644
index 0000000..2cc3368
--- /dev/null
+++ b/hurd/hurdrlimit.c
@@ -0,0 +1,50 @@
+/* Resource limits.
+Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <cthreads.h>
+#include <hurd/resource.h>
+
+/* This must be given an initializer, or the a.out linking rules will
+   not include the entire file when this symbol is referenced. */
+struct rlimit _hurd_rlimits[RLIM_NLIMITS] = { { 0, }, };
+
+/* This must be initialized data for the same reason as above, but this is
+   intentionally initialized to a bogus value to emphasize the point that
+   mutex_init is still required below just in case of unexec.  */
+struct mutex _hurd_rlimit_lock = { SPIN_LOCK_INITIALIZER, };
+
+static void
+init_rlimit (void)
+{
+  int i;
+
+  __mutex_init (&_hurd_rlimit_lock);
+
+  for (i = 0; i < RLIM_NLIMITS; ++i)
+    {
+      if (_hurd_rlimits[i].rlim_max == 0)
+	_hurd_rlimits[i].rlim_max = RLIM_INFINITY;
+      if (_hurd_rlimits[i].rlim_cur == 0)
+	_hurd_rlimits[i].rlim_cur = _hurd_rlimits[i].rlim_max;
+    }
+
+  (void) &init_rlimit;
+}
+text_set_element (_hurd_preinit_hook, init_rlimit);
diff --git a/hurd/hurdsig.c b/hurd/hurdsig.c
new file mode 100644
index 0000000..2c6f6a1
--- /dev/null
+++ b/hurd/hurdsig.c
@@ -0,0 +1,1080 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <hurd.h>
+#include <hurd/signal.h>
+#include <cthreads.h>		/* For `struct mutex'.  */
+#include <string.h>
+#include "hurdfault.h"
+#include "hurdmalloc.h"		/* XXX */
+
+const char *_hurdsig_getenv (const char *);
+
+struct mutex _hurd_siglock;
+int _hurd_stopped;
+
+/* Port that receives signals and other miscellaneous messages.  */
+mach_port_t _hurd_msgport;
+
+/* Thread listening on it.  */
+thread_t _hurd_msgport_thread;
+
+/* Thread which receives task-global signals.  */
+thread_t _hurd_sigthread;
+
+/* Linked-list of per-thread signal state.  */
+struct hurd_sigstate *_hurd_sigstates;
+
+static void
+default_sigaction (struct sigaction actions[NSIG])
+{
+  int signo;
+
+  __sigemptyset (&actions[0].sa_mask);
+  actions[0].sa_flags = SA_RESTART;
+  actions[0].sa_handler = SIG_DFL;
+
+  for (signo = 1; signo < NSIG; ++signo)
+    actions[signo] = actions[0];
+}
+
+struct hurd_sigstate *
+_hurd_thread_sigstate (thread_t thread)
+{
+  struct hurd_sigstate *ss;
+  __mutex_lock (&_hurd_siglock);
+  for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
+    if (ss->thread == thread)
+      break;
+  if (ss == NULL)
+    {
+      ss = malloc (sizeof (*ss));
+      if (ss == NULL)
+	__libc_fatal ("hurd: Can't allocate thread sigstate\n");
+      ss->thread = thread;
+      __spin_lock_init (&ss->lock);
+
+      /* Initialze default state.  */
+      __sigemptyset (&ss->blocked);
+      __sigemptyset (&ss->pending);
+      memset (&ss->sigaltstack, 0, sizeof (ss->sigaltstack));
+      ss->suspended = 0;
+#ifdef noteven
+      __condition_init (&ss->arrived);
+#endif
+      ss->intr_port = MACH_PORT_NULL;
+      ss->context = NULL;
+
+      /* Initialize the sigaction vector from the default signal receiving
+	 thread's state, and its from the system defaults.  */
+      if (thread == _hurd_sigthread)
+	default_sigaction (ss->actions);
+      else
+	{
+	  struct hurd_sigstate *s;
+	  for (s = _hurd_sigstates; s != NULL; s = s->next)
+	    if (s->thread == _hurd_sigthread)
+	      break;
+	  if (s)
+	    {
+	      __spin_lock (&s->lock);
+	      memcpy (ss->actions, s->actions, sizeof (s->actions));
+	      __spin_unlock (&s->lock);
+	    }
+	  else
+	    default_sigaction (ss->actions);
+	}
+
+      ss->next = _hurd_sigstates;
+      _hurd_sigstates = ss;
+    }
+  __mutex_unlock (&_hurd_siglock);
+  return ss;
+}
+
+/* Signal delivery itself is on this page.  */
+
+#include <hurd/fd.h>
+#include <hurd/core.h>
+#include <hurd/paths.h>
+#include <setjmp.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include "thread_state.h"
+#include <hurd/msg_server.h>
+#include <hurd/msg_reply.h>	/* For __msg_sig_post_reply.  */
+#include <assert.h>
+#include <hurd/interrupt.h>
+
+int _hurd_core_limit;	/* XXX */
+
+/* Call the core server to mummify us before we die.
+   Returns nonzero if a core file was written.  */
+static int
+write_corefile (int signo, long int sigcode, int sigerror)
+{
+  error_t err;
+  mach_port_t coreserver;
+  file_t file, coredir;
+  const char *name;
+
+  /* XXX RLIMIT_CORE:
+     When we have a protocol to make the server return an error
+     for RLIMIT_FSIZE, then tell the corefile fs server the RLIMIT_CORE
+     value in place of the RLIMIT_FSIZE value.  */
+
+  /* First get a port to the core dumping server.  */
+  coreserver = MACH_PORT_NULL;
+  name = _hurdsig_getenv ("CORESERVER");
+  if (name != NULL)
+    coreserver = __file_name_lookup (name, 0, 0);
+  if (coreserver == MACH_PORT_NULL)
+    coreserver = __file_name_lookup (_SERVERS_CORE, 0, 0);
+  if (coreserver == MACH_PORT_NULL)
+    return 0;
+
+  /* Get a port to the directory where the new core file will reside.  */
+  name = _hurdsig_getenv ("COREFILE");
+  if (name == NULL)
+    name = "core";
+  coredir = __file_name_split (name, (char **) &name);
+  if (coredir == MACH_PORT_NULL)
+    return 0;
+  /* Create the new file, but don't link it into the directory yet.  */
+  if (err = __dir_mkfile (coredir, O_WRONLY|O_CREAT,
+			  0600 & ~_hurd_umask, /* XXX ? */
+			  &file))
+    return 0;
+
+  /* Call the core dumping server to write the core file.  */
+  err = __core_dump_task (coreserver,
+			  __mach_task_self (),
+			  file, _hurdsig_getenv ("GNUTARGET"),
+			  signo, sigcode, sigerror);
+  __mach_port_deallocate (__mach_task_self (), coreserver);
+  if (! err)
+    /* The core dump into FILE succeeded, so now link it into the
+       directory.  */
+    err = __dir_link (file, coredir, name);
+  __mach_port_deallocate (__mach_task_self (), file);
+  __mach_port_deallocate (__mach_task_self (), coredir);
+  return !err;
+}
+
+
+/* Send a sig_post reply message if it hasn't already been sent.  */
+static inline void
+post_reply (mach_port_t *reply_port, mach_msg_type_name_t reply_port_type,
+	    int untraced,
+	    error_t result)
+{
+  if (reply_port == NULL || *reply_port == MACH_PORT_NULL)
+    return;
+  (untraced ? __msg_sig_post_untraced_reply : __msg_sig_post_reply)
+    (*reply_port, reply_port_type, result);
+  *reply_port = MACH_PORT_NULL;
+}
+
+
+/* The lowest-numbered thread state flavor value is 1,
+   so we use bit 0 in machine_thread_all_state.set to
+   record whether we have done thread_abort.  */
+#define THREAD_ABORTED 1
+
+/* SS->thread is suspended.  Abort the thread and get its basic state.  If
+   REPLY_PORT is not NULL, send a reply on *REPLY_PORT after aborting the
+   thread.  */
+static void
+abort_thread (struct hurd_sigstate *ss, struct machine_thread_all_state *state,
+	      mach_port_t *reply_port, mach_msg_type_name_t reply_port_type,
+	      int untraced)
+{
+  if (!(state->set & THREAD_ABORTED))
+    {
+      __thread_abort (ss->thread);
+      /* Clear all thread state flavor set bits, because thread_abort may
+	 have changed the state.  */
+      state->set = THREAD_ABORTED;
+    }
+
+  if (reply_port)
+    post_reply (reply_port, reply_port_type, untraced, 0);
+
+  machine_get_basic_state (ss->thread, state);
+}
+
+/* Find the location of the MiG reply port cell in use by the thread whose
+   state is described by THREAD_STATE.  Make sure that this location can be
+   set without faulting, or else return NULL.  */
+
+static mach_port_t *
+interrupted_reply_port_location (struct machine_thread_all_state *thread_state)
+{
+  mach_port_t *portloc = (mach_port_t *) __hurd_threadvar_location_from_sp
+    (_HURD_THREADVAR_MIG_REPLY, (void *) thread_state->basic.SP);
+
+  if (_hurdsig_catch_fault (SIGSEGV))
+    {
+      assert (_hurdsig_fault_sigcode == (long int) portloc);
+      /* Faulted trying to read the stack.  */
+      return NULL;
+    }
+
+  /* Fault now if this pointer is bogus.  */
+  *(volatile mach_port_t *) portloc = *portloc;
+
+  _hurdsig_end_catch_fault ();
+
+  return portloc;
+}
+
+
+/* SS->thread is suspended.
+
+   Abort any interruptible RPC operation the thread is doing.
+
+   This uses only the constant member SS->thread and the unlocked, atomically
+   set member SS->intr_port, so no locking is needed.
+
+   If successfully sent an interrupt_operation and therefore the thread should
+   wait for its pending RPC to return (possibly EINTR) before taking the
+   incoming signal, returns the reply port to be received on.  Otherwise
+   returns MACH_PORT_NULL.
+
+   *STATE_CHANGE is set nonzero if STATE->basic was modified and should
+   be applied back to the thread if it might ever run again, else zero.  */
+
+static mach_port_t
+abort_rpcs (struct hurd_sigstate *ss, int signo,
+	    struct machine_thread_all_state *state, int *state_change,
+	    mach_port_t *reply_port, mach_msg_type_name_t reply_port_type,
+	    int untraced)
+{
+  mach_port_t msging_port;
+  mach_port_t intr_port;
+
+  *state_change = 0;
+
+  intr_port = ss->intr_port;
+  if (intr_port == MACH_PORT_NULL)
+    /* No interruption needs done.  */
+    return MACH_PORT_NULL;
+
+  /* Abort the thread's kernel context, so any pending message send or
+     receive completes immediately or aborts.  */
+  abort_thread (ss, state, reply_port, reply_port_type, untraced);
+
+  if (_hurdsig_rcv_interrupted_p (state, &msging_port))
+    {
+      error_t err;
+
+      /* The RPC request message was sent and the thread was waiting for
+	 the reply message; now the message receive has been aborted, so
+	 the mach_msg_call will return MACH_RCV_INTERRUPTED.  We must tell
+	 the server to interrupt the pending operation.  The thread must
+	 wait for the reply message before running the signal handler (to
+	 guarantee that the operation has finished being interrupted), so
+	 our nonzero return tells the trampoline code to finish the message
+	 receive operation before running the handler.  */
+
+      err = __interrupt_operation (intr_port);
+
+      if (err)
+	{
+	  mach_port_t *reply;
+
+	  /* The interrupt didn't work.
+	     Destroy the receive right the thread is blocked on.  */
+	  __mach_port_destroy (__mach_task_self (), msging_port);
+
+	  /* The system call return value register now contains
+	     MACH_RCV_INTERRUPTED; when mach_msg resumes, it will retry the
+	     call.  Since we have just destroyed the receive right, the
+	     retry will fail with MACH_RCV_INVALID_NAME.  Instead, just
+	     change the return value here to EINTR so mach_msg will not
+	     retry and the EINTR error code will propagate up.  */
+	  state->basic.SYSRETURN = EINTR;
+	  *state_change = 1;
+
+	  /* If that was the thread's MiG reply port (which I think should
+	     always be the case), clear the reply port cell so it won't be
+	     reused.  */
+	  reply = interrupted_reply_port_location (state);
+	  if (reply != NULL && *reply == msging_port)
+	    *reply = MACH_PORT_NULL;
+	}
+
+      /* All threads whose RPCs were interrupted by the interrupt_operation
+	 call above will retry their RPCs unless we clear SS->intr_port.
+	 So we clear it for the thread taking a signal when SA_RESTART is
+	 clear, so that its call returns EINTR.  */
+      if (!(ss->actions[signo].sa_flags & SA_RESTART))
+	ss->intr_port = MACH_PORT_NULL;
+
+      return err ? MACH_PORT_NULL : msging_port;
+    }
+
+  /* One of the following is true:
+
+     1. The RPC has not yet been sent.  The thread will start its operation
+     after the signal has been handled.
+
+     2. The RPC has finished, but not yet cleared SS->intr_port.
+     The thread will clear SS->intr_port after running the handler.
+
+     3. The RPC request message was being sent was aborted.  The mach_msg
+     system call will return MACH_SEND_INTERRUPTED, and HURD_EINTR_RPC will
+     notice the interruption (either retrying the RPC or returning EINTR).  */
+
+  return MACH_PORT_NULL;
+}
+
+/* Abort the RPCs being run by all threads but this one;
+   all other threads should be suspended.  If LIVE is nonzero, those
+   threads may run again, so they should be adjusted as necessary to be
+   happy when resumed.  STATE is clobbered as a scratch area; its initial
+   contents are ignored, and its contents on return are not useful.  */
+
+static void
+abort_all_rpcs (int signo, struct machine_thread_all_state *state, int live)
+{
+  /* We can just loop over the sigstates.  Any thread doing something
+     interruptible must have one.  We needn't bother locking because all
+     other threads are stopped.  */
+
+  struct hurd_sigstate *ss;
+  size_t nthreads;
+  mach_port_t *reply_ports;
+
+  /* First loop over the sigstates to count them.
+     We need to know how big a vector we will need for REPLY_PORTS.  */
+  nthreads = 0;
+  for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
+    ++nthreads;
+
+  reply_ports = alloca (nthreads * sizeof *reply_ports);
+
+  nthreads = 0;
+  for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
+    if (ss->thread == _hurd_msgport_thread)
+      reply_ports[nthreads++] = MACH_PORT_NULL;
+    else
+      {
+	int state_changed;
+	state->set = 0;		/* Reset scratch area.  */
+
+	/* Abort any operation in progress with interrupt_operation.
+	   Record the reply port the thread is waiting on.
+	   We will wait for all the replies below.  */
+	reply_ports[nthreads++] = abort_rpcs (ss, signo, state, &state_changed,
+					      NULL, 0, 0);
+	if (state_changed && live)
+	  /* Aborting the RPC needed to change this thread's state,
+	     and it might ever run again.  So write back its state.  */
+	  __thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
+			      (natural_t *) &state->basic,
+			      MACHINE_THREAD_STATE_COUNT);
+      }
+
+  /* Wait for replies from all the successfully interrupted RPCs.  */
+  while (nthreads-- > 0)
+    if (reply_ports[nthreads] != MACH_PORT_NULL)
+      {
+	error_t err;
+	mach_msg_header_t head;
+	err = __mach_msg (&head, MACH_RCV_MSG, 0, sizeof head,
+			  reply_ports[nthreads],
+			  MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+	if (err != MACH_RCV_TOO_LARGE)
+	  assert_perror (err);
+      }
+}
+
+
+struct hurd_signal_preempt *_hurd_signal_preempt[NSIG];
+struct mutex _hurd_signal_preempt_lock;
+
+/* Mask of stop signals.  */
+#define STOPSIGS (sigmask (SIGTTIN) | sigmask (SIGTTOU) | \
+		  sigmask (SIGSTOP) | sigmask (SIGTSTP))
+
+/* Deliver a signal.  SS is not locked.  */
+void
+_hurd_internal_post_signal (struct hurd_sigstate *ss,
+			    int signo, long int sigcode, int sigerror,
+			    mach_port_t reply_port,
+			    mach_msg_type_name_t reply_port_type,
+			    int untraced)
+{
+  struct machine_thread_all_state thread_state;
+  enum { stop, ignore, core, term, handle } act;
+  sighandler_t handler;
+  struct hurd_signal_preempt *pe;
+  sighandler_t (*preempt) (thread_t, int, long int, int) = NULL;
+  sigset_t pending;
+  int ss_suspended;
+
+  /* Reply to this sig_post message.  */
+  inline void reply (void)
+    {
+      post_reply (&reply_port, reply_port_type, untraced, 0);
+    }
+
+  /* Mark the signal as pending.  */
+  void mark_pending (void)
+    {
+      __sigaddset (&ss->pending, signo);
+      /* Save the code to be given to the handler when SIGNO is
+	 unblocked.  */
+      ss->pending_data[signo].code = sigcode;
+      ss->pending_data[signo].error = sigerror;
+    }
+
+  /* Suspend the process with SIGNO.  */
+  void suspend (void)
+    {
+      /* Stop all other threads and mark ourselves stopped.  */
+      __USEPORT (PROC,
+		 ({
+		   /* Hold the siglock while stopping other threads to be
+		      sure it is not held by another thread afterwards.  */
+		   __mutex_lock (&_hurd_siglock);
+		   __proc_dostop (port, _hurd_msgport_thread);
+		   __mutex_unlock (&_hurd_siglock);
+		   abort_all_rpcs (signo, &thread_state, 1);
+		   __proc_mark_stop (port, signo);
+		 }));
+      _hurd_stopped = 1;
+    }
+
+ post_signal:
+
+  thread_state.set = 0;		/* We know nothing.  */
+
+  /* Check for a preempted signal.  Preempted signals
+     can arrive during critical sections.  */
+  __mutex_lock (&_hurd_signal_preempt_lock);
+  for (pe = _hurd_signal_preempt[signo]; pe != NULL; pe = pe->next)
+    if (sigcode >= pe->first && sigcode <= pe->last)
+      {
+	preempt = pe->handler;
+	break;
+      }
+  __mutex_unlock (&_hurd_signal_preempt_lock);
+
+  handler = SIG_DFL;
+  if (preempt)
+    /* Let the preempting handler examine the thread.
+       If it returns SIG_DFL, we run the normal handler;
+       otherwise we use the handler it returns.  */
+    handler = (*preempt) (ss->thread, signo, sigcode, sigerror);
+
+  ss_suspended = 0;
+
+  if (handler != SIG_DFL)
+    /* Run the preemption-provided handler.  */
+    act = handle;
+  else
+    {
+      /* No preemption.  Do normal handling.  */
+
+      __spin_lock (&ss->lock);
+
+      handler = ss->actions[signo].sa_handler;
+
+      if (!untraced && (_hurd_exec_flags & EXEC_TRACED))
+	{
+	  /* We are being traced.  Stop to tell the debugger of the signal.  */
+	  if (_hurd_stopped)
+	    /* Already stopped.  Mark the signal as pending;
+	       when resumed, we will notice it and stop again.  */
+	    mark_pending ();
+	  else
+	    suspend ();
+	  __spin_unlock (&ss->lock);
+	  reply ();
+	  return;
+	}
+
+      if (handler == SIG_DFL)
+	/* Figure out the default action for this signal.  */
+	switch (signo)
+	  {
+	  case 0:
+	    /* A sig_post msg with SIGNO==0 is sent to
+	       tell us to check for pending signals.  */
+	    act = ignore;
+	    break;
+
+	  case SIGTTIN:
+	  case SIGTTOU:
+	  case SIGSTOP:
+	  case SIGTSTP:
+	    act = stop;
+	    break;
+
+	  case SIGCONT:
+	  case SIGIO:
+	  case SIGURG:
+	  case SIGCHLD:
+	  case SIGWINCH:
+	    act = ignore;
+	    break;
+
+	  case SIGQUIT:
+	  case SIGILL:
+	  case SIGTRAP:
+	  case SIGIOT:
+	  case SIGEMT:
+	  case SIGFPE:
+	  case SIGBUS:
+	  case SIGSEGV:
+	  case SIGSYS:
+	    act = core;
+	    break;
+
+	  case SIGINFO:
+	    if (_hurd_pgrp == _hurd_pid)
+	      {
+		/* We are the process group leader.  Since there is no
+		   user-specified handler for SIGINFO, we use a default one
+		   which prints something interesting.  We use the normal
+		   handler mechanism instead of just doing it here to avoid
+		   the signal thread faulting or blocking in this
+		   potentially hairy operation.  */
+		act = handle;
+		handler = _hurd_siginfo_handler;
+	      }
+	    else
+	      act = ignore;
+	    break;
+
+	  default:
+	    act = term;
+	    break;
+	  }
+      else if (handler == SIG_IGN)
+	act = ignore;
+      else
+	act = handle;
+
+      if (__sigmask (signo) & STOPSIGS)
+	/* Stop signals clear a pending SIGCONT even if they
+	   are handled or ignored (but not if preempted).  */
+	ss->pending &= ~sigmask (SIGCONT);
+      else
+	{
+	  if (signo == SIGCONT)
+	    /* Even if handled or ignored (but not preempted), SIGCONT clears
+	       stop signals and resumes the process.  */
+	    ss->pending &= ~STOPSIGS;
+
+	  if (_hurd_stopped && act != stop && (untraced || signo == SIGCONT))
+	    {
+	      /* Resume the process from being stopped.  */
+	      thread_t *threads;
+	      mach_msg_type_number_t nthreads, i;
+	      error_t err;
+	      /* Tell the proc server we are continuing.  */
+	      __USEPORT (PROC, __proc_mark_cont (port));
+	      /* Fetch ports to all our threads and resume them.  */
+	      err = __task_threads (__mach_task_self (), &threads, &nthreads);
+	      assert_perror (err);
+	      for (i = 0; i < nthreads; ++i)
+		{
+		  if (threads[i] != _hurd_msgport_thread &&
+		      (act != handle || threads[i] != ss->thread))
+		    __thread_resume (threads[i]);
+		  __mach_port_deallocate (__mach_task_self (), threads[i]);
+		}
+	      __vm_deallocate (__mach_task_self (),
+			       (vm_address_t) threads,
+			       nthreads * sizeof *threads);
+	      _hurd_stopped = 0;
+	      /* The thread that will run the handler is already suspended.  */
+	      ss_suspended = 1;
+	    }
+	}
+    }
+
+  if (_hurd_orphaned && act == stop &&
+      (__sigmask (signo) & (__sigmask (SIGTTIN) | __sigmask (SIGTTOU) |
+			    __sigmask (SIGTSTP))))
+    {
+      /* If we would ordinarily stop for a job control signal, but we are
+	 orphaned so noone would ever notice and continue us again, we just
+	 quietly die, alone and in the dark.  */
+      sigcode = signo;
+      signo = SIGKILL;
+      act = term;
+    }
+
+  /* Handle receipt of a blocked signal, or any signal while stopped.
+     It matters that we test ACT first here, because we must never pass
+     SIGNO==0 to __sigismember.  */
+  if ((act != ignore && __sigismember (&ss->blocked, signo)) ||
+      (signo != SIGKILL && _hurd_stopped))
+    {
+      mark_pending ();
+      act = ignore;
+    }
+
+  /* Perform the chosen action for the signal.  */
+  switch (act)
+    {
+    case stop:
+      if (_hurd_stopped)
+	/* We are already stopped, but receiving an untraced stop
+	   signal.  Instead of resuming and suspending again, just
+	   notify the proc server of the new stop signal.  */
+	__USEPORT (PROC, __proc_mark_stop (port, signo));
+      else
+	/* Suspend the process.  */
+	suspend ();
+      break;
+
+    case ignore:
+      /* Nobody cares about this signal.  */
+      break;
+
+    case term:			/* Time to die.  */
+    case core:			/* And leave a rotting corpse.  */
+    nirvana:
+      /* Have the proc server stop all other threads in our task.  */
+      __USEPORT (PROC, __proc_dostop (port, _hurd_msgport_thread));
+      /* No more user instructions will be executed.
+	 The signal can now be considered delivered.  */
+      reply ();
+      /* Abort all server operations now in progress.  */
+      abort_all_rpcs (signo, &thread_state, 0);
+
+      {
+	int status = W_EXITCODE (0, signo);
+	/* Do a core dump if desired.  Only set the wait status bit saying we
+	   in fact dumped core if the operation was actually successful.  */
+	if (act == core && write_corefile (signo, sigcode, sigerror))
+	  status |= WCOREFLAG;
+	/* Tell proc how we died and then stick the saber in the gut.  */
+	_hurd_exit (status);
+	/* NOTREACHED */
+      }
+
+    case handle:
+      /* Call a handler for this signal.  */
+      {
+	struct sigcontext *scp;
+	int wait_for_reply, state_changed;
+
+	/* Stop the thread and abort its pending RPC operations.  */
+	if (! ss_suspended)
+	  __thread_suspend (ss->thread);
+
+	/* Abort the thread's kernel context, so any pending message send
+	   or receive completes immediately or aborts.  If an interruptible
+	   RPC is in progress, abort_rpcs will do this.  But we must always
+	   do it before fetching the thread's state, because
+	   thread_get_state is never kosher before thread_abort.  */
+	abort_thread (ss, &thread_state, NULL, 0, 0);
+
+	wait_for_reply = (abort_rpcs (ss, signo, &thread_state, &state_changed,
+				      &reply_port, reply_port_type, untraced)
+			  != MACH_PORT_NULL);
+
+	if (ss->critical_section)
+	  {
+	    /* The thread is in a critical section.  Mark the signal as
+	       pending.  When it finishes the critical section, it will
+	       check for pending signals.  */
+	    mark_pending ();
+	    assert (! state_changed);
+	    __thread_resume (ss->thread);
+	    break;
+	  }
+
+	/* Call the machine-dependent function to set the thread up
+	   to run the signal handler, and preserve its old context.  */
+	scp = _hurd_setup_sighandler (ss, handler,
+				      signo, sigcode,
+				      wait_for_reply, &thread_state);
+	if (scp == NULL)
+	  {
+	    /* We got a fault setting up the stack frame for the handler.
+	       Nothing to do but die; BSD gets SIGILL in this case.  */
+	    sigcode = signo;	/* XXX ? */
+	    signo = SIGILL;
+	    act = core;
+	    goto nirvana;
+	  }
+
+	/* Set the machine-independent parts of the signal context.  */
+
+	scp->sc_error = sigerror;
+	{
+	  /* Fetch the thread variable for the MiG reply port,
+	     and set it to MACH_PORT_NULL.  */
+	  mach_port_t *loc = interrupted_reply_port_location (&thread_state);
+	  if (loc)
+	    {
+	      scp->sc_reply_port = *loc;
+	      *loc = MACH_PORT_NULL;
+	    }
+	  else
+	    scp->sc_reply_port = MACH_PORT_NULL;
+	}
+
+	/* Block SIGNO and requested signals while running the handler.  */
+	scp->sc_mask = ss->blocked;
+	ss->blocked |= __sigmask (signo) | ss->actions[signo].sa_mask;
+
+	/* Save the intr_port in use by the interrupted code,
+	   and clear the cell before running the trampoline.  */
+	scp->sc_intr_port = ss->intr_port;
+	ss->intr_port = MACH_PORT_NULL;
+
+	/* Start the thread running the handler (or possibly waiting for an
+	   RPC reply before running the handler).  */
+	__thread_set_state (ss->thread, MACHINE_THREAD_STATE_FLAVOR,
+			    (natural_t *) &thread_state.basic,
+			    MACHINE_THREAD_STATE_COUNT);
+	__thread_resume (ss->thread);
+	thread_state.set = 0;	/* Everything we know is now wrong.  */
+	break;
+      }
+    }
+
+  /* The signal has either been ignored or is now being handled.  We can
+     consider it delivered and reply to the killer.  The exception is
+     signal 0, which can be sent by a user thread to make us check for
+     pending signals.  In that case we want to deliver the pending signals
+     before replying.  */
+  if (signo != 0)
+    reply ();
+
+  /* We get here unless the signal was fatal.  We still hold SS->lock.
+     Check for pending signals, and loop to post them.  */
+#define PENDING	(!_hurd_stopped && (pending = ss->pending & ~ss->blocked))
+  if (PENDING)
+    {
+    pending:
+      for (signo = 1; signo < NSIG; ++signo)
+	if (__sigismember (&pending, signo))
+	  {
+	    __sigdelset (&ss->pending, signo);
+	    sigcode = ss->pending_data[signo].code;
+	    sigerror = ss->pending_data[signo].error;
+	    __spin_unlock (&ss->lock);
+	    goto post_signal;
+	  }
+    }
+
+  /* No pending signals left undelivered for this thread.
+     If we were sent signal 0, we need to check for pending
+     signals for all threads.  */
+  if (signo == 0)
+    {
+      __spin_unlock (&ss->lock);
+      __mutex_lock (&_hurd_siglock);
+      for (ss = _hurd_sigstates; ss != NULL; ss = ss->next)
+	{
+	  __spin_lock (&ss->lock);
+	  if (PENDING)
+	    goto pending;
+	  __spin_unlock (&ss->lock);
+	}
+      __mutex_unlock (&_hurd_siglock);
+    }
+  else
+    {
+      /* No more signals pending; SS->lock is still locked.
+	 Wake up any sigsuspend call that is blocking SS->thread.  */
+      if (ss->suspended != MACH_PORT_NULL)
+	{
+	  /* There is a sigsuspend waiting.  Tell it to wake up.  */
+	  error_t err;
+	  mach_msg_header_t msg;
+	  err = __mach_port_insert_right (__mach_task_self (),
+					  ss->suspended, ss->suspended,
+					  MACH_MSG_TYPE_MAKE_SEND);
+	  assert_perror (err);
+	  msg.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_MOVE_SEND, 0);
+	  msg.msgh_remote_port = ss->suspended;
+	  msg.msgh_local_port = MACH_PORT_NULL;
+	  /* These values do not matter.  */
+	  msg.msgh_id = 8675309; /* Jenny, Jenny.  */
+	  msg.msgh_seqno = 17;	/* Random.  */
+	  ss->suspended = MACH_PORT_NULL;
+	  err = __mach_msg (&msg, MACH_SEND_MSG, sizeof msg, 0,
+			    MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
+			    MACH_PORT_NULL);
+	  assert_perror (err);
+	}
+      __spin_unlock (&ss->lock);
+    }
+
+  /* All pending signals delivered to all threads.
+     Now we can send the reply message even for signal 0.  */
+  reply ();
+}
+
+/* Decide whether REFPORT enables the sender to send us a SIGNO signal.
+   Returns zero if so, otherwise the error code to return to the sender.  */
+
+static error_t
+signal_allowed (int signo, mach_port_t refport)
+{
+  if (signo < 0 || signo >= NSIG)
+    return EINVAL;
+
+  if (refport == __mach_task_self ())
+    /* Can send any signal.  */
+    goto win;
+
+  /* Avoid needing to check for this below.  */
+  if (refport == MACH_PORT_NULL)
+    return EPERM;
+
+  switch (signo)
+    {
+    case SIGINT:
+    case SIGQUIT:
+    case SIGTSTP:
+    case SIGHUP:
+    case SIGINFO:
+    case SIGTTIN:
+    case SIGTTOU:
+      /* Job control signals can be sent by the controlling terminal.  */
+      if (__USEPORT (CTTYID, port == refport))
+	goto win;
+      break;
+
+    case SIGCONT:
+      {
+	/* A continue signal can be sent by anyone in the session.  */
+	mach_port_t sessport;
+	if (! __USEPORT (PROC, __proc_getsidport (port, &sessport)))
+	  { 
+	    __mach_port_deallocate (__mach_task_self (), sessport);
+	    if (refport == sessport)
+	      goto win;
+	  }
+      }
+      break;
+
+    case SIGIO:
+    case SIGURG:
+      {
+	/* Any io object a file descriptor refers to might send us
+	   one of these signals using its async ID port for REFPORT.
+
+	   This is pretty wide open; it is not unlikely that some random
+	   process can at least open for reading something we have open,
+	   get its async ID port, and send us a spurious SIGIO or SIGURG
+	   signal.  But BSD is actually wider open than that!--you can set
+	   the owner of an io object to any process or process group
+	   whatsoever and send them gratuitous signals.
+
+	   Someday we could implement some reasonable scheme for
+	   authorizing SIGIO and SIGURG signals properly.  */
+
+	int d;
+	__mutex_lock (&_hurd_dtable_lock);
+	for (d = 0; (unsigned int) d < (unsigned int) _hurd_dtablesize; ++d)
+	  {
+	    struct hurd_userlink ulink;
+	    io_t port;
+	    mach_port_t asyncid;
+	    if (_hurd_dtable[d] == NULL)
+	      continue;
+	    port = _hurd_port_get (&_hurd_dtable[d]->port, &ulink);
+	    if (! __io_get_icky_async_id (port, &asyncid))
+	      {
+		if (refport == asyncid)
+		  /* Break out of the loop on the next iteration.  */
+		  d = -1;
+		__mach_port_deallocate (__mach_task_self (), asyncid);
+	      }
+	    _hurd_port_free (&_hurd_dtable[d]->port, &ulink, port);
+	  }
+	/* If we found a lucky winner, we've set D to -1 in the loop.  */
+	if (d < 0)
+	  goto win;
+      }
+    }
+
+  /* If this signal is legit, we have done `goto win' by now.
+     When we return the error, mig deallocates REFPORT.  */
+  return EPERM;
+
+ win:
+  /* Deallocate the REFPORT send right; we are done with it.  */
+  __mach_port_deallocate (__mach_task_self (), refport);
+
+  return 0;
+}
+
+/* Implement the sig_post RPC from <hurd/msg.defs>;
+   sent when someone wants us to get a signal.  */
+kern_return_t
+_S_msg_sig_post (mach_port_t me,
+		 mach_port_t reply_port, mach_msg_type_name_t reply_port_type,
+		 int signo,
+		 mach_port_t refport)
+{
+  error_t err;
+
+  if (err = signal_allowed (signo, refport))
+    return err;
+
+  /* Post the signal to the designated signal-receiving thread.  This will
+     reply when the signal can be considered delivered.  */
+  _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
+			      signo, 0, 0, reply_port, reply_port_type,
+			      0); /* Stop if traced.  */
+
+  return MIG_NO_REPLY;		/* Already replied.  */
+}
+
+/* Implement the sig_post_untraced RPC from <hurd/msg.defs>;
+   sent when the debugger wants us to really get a signal
+   even if we are traced.  */
+kern_return_t
+_S_msg_sig_post_untraced (mach_port_t me,
+			  mach_port_t reply_port,
+			  mach_msg_type_name_t reply_port_type,
+			  int signo,
+			  mach_port_t refport)
+{
+  error_t err;
+
+  if (err = signal_allowed (signo, refport))
+    return err;
+
+  /* Post the signal to the designated signal-receiving thread.  This will
+     reply when the signal can be considered delivered.  */
+  _hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
+			      signo, 0, 0, reply_port, reply_port_type,
+			      1); /* Untraced flag. */
+
+  return MIG_NO_REPLY;		/* Already replied.  */
+}
+
+extern void __mig_init (void *);
+
+#include <mach/task_special_ports.h>
+
+/* Initialize the message port and _hurd_sigthread and start the signal
+   thread.  */
+
+void
+_hurdsig_init (void)
+{
+  error_t err;
+  vm_size_t stacksize;
+
+  __mutex_init (&_hurd_siglock);
+
+  if (err = __mach_port_allocate (__mach_task_self (),
+				  MACH_PORT_RIGHT_RECEIVE,
+				  &_hurd_msgport))
+    __libc_fatal ("hurd: Can't create message port receive right\n");
+  
+  /* Make a send right to the signal port.  */
+  if (err = __mach_port_insert_right (__mach_task_self (),
+				      _hurd_msgport,
+				      _hurd_msgport,
+				      MACH_MSG_TYPE_MAKE_SEND))
+    __libc_fatal ("hurd: Can't create send right to message port\n");
+
+  /* Set the default thread to receive task-global signals
+     to this one, the main (first) user thread.  */
+  _hurd_sigthread = __mach_thread_self ();
+
+  /* Start the signal thread listening on the message port.  */
+
+  if (err = __thread_create (__mach_task_self (), &_hurd_msgport_thread))
+    __libc_fatal ("hurd: Can't create signal thread\n");
+
+  stacksize = __vm_page_size * 4; /* Small stack for signal thread.  */
+  if (err = __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread,
+				 _hurd_msgport_receive,
+				 (vm_address_t *) &__hurd_sigthread_stack_base,
+				 &stacksize))
+    __libc_fatal ("hurd: Can't setup signal thread\n");
+
+  __hurd_sigthread_stack_end = __hurd_sigthread_stack_base + stacksize;
+  __hurd_sigthread_variables =
+    malloc (__hurd_threadvar_max * sizeof (unsigned long int));
+  if (__hurd_sigthread_variables == NULL)
+    __libc_fatal ("hurd: Can't allocate thread variables for signal thread\n");
+
+  /* Reinitialize the MiG support routines so they will use a per-thread
+     variable for the cached reply port.  */
+  __mig_init ((void *) __hurd_sigthread_stack_base);
+
+  if (err = __thread_resume (_hurd_msgport_thread))
+    __libc_fatal ("hurd: Can't resume signal thread\n");
+    
+#if 0				/* Don't confuse poor gdb.  */
+  /* Receive exceptions on the signal port.  */
+  __task_set_special_port (__mach_task_self (),
+			   TASK_EXCEPTION_PORT, _hurd_msgport);
+#endif
+}
+				/* XXXX */
+/* Reauthenticate with the proc server.  */
+
+static void
+reauth_proc (mach_port_t new)
+{
+  mach_port_t ref, ignore;
+
+  ref = __mach_reply_port ();
+  if (! HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC],
+		       __proc_reauthenticate (port, ref,
+					      MACH_MSG_TYPE_MAKE_SEND) ||
+		       __auth_user_authenticate (new, port, ref,
+						 MACH_MSG_TYPE_MAKE_SEND,
+						 &ignore))
+      && ignore != MACH_PORT_NULL)
+    __mach_port_deallocate (__mach_task_self (), ignore);
+  __mach_port_destroy (__mach_task_self (), ref);
+
+  (void) &reauth_proc;		/* Silence compiler warning.  */
+}
+text_set_element (_hurd_reauth_hook, reauth_proc);
+
+/* Like `getenv', but safe for the signal thread to run.
+   If the environment is trashed, this will just return NULL.  */
+
+const char *
+_hurdsig_getenv (const char *variable)
+{
+  if (_hurdsig_catch_fault (SIGSEGV))
+    /* We bombed in getenv.  */
+    return NULL;
+  else
+    {
+      const char *value = getenv (variable);
+      /* Fault now if VALUE is a bogus string.  */
+      (void) strlen (value);
+      _hurdsig_end_catch_fault ();
+      return value;
+    }
+}
diff --git a/hurd/hurdsock.c b/hurd/hurdsock.c
new file mode 100644
index 0000000..266fd40
--- /dev/null
+++ b/hurd/hurdsock.c
@@ -0,0 +1,115 @@
+/* _hurd_socket_server - Find the server for a socket domain.
+
+Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <sys/socket.h>
+#include <stdlib.h>
+#include <string.h>
+#include <hurd/paths.h>
+#include <stdio.h>
+#include "stdio/_itoa.h"
+#include <cthreads.h>		/* For `struct mutex'.  */
+#include "hurdmalloc.h"		/* XXX */
+
+static struct mutex lock;
+
+static file_t *servers;
+static int max_domain;
+
+/* Return a port to the socket server for DOMAIN.
+   Socket servers translate nodes in the directory _SERVERS_SOCKET
+   (canonically /servers/socket).  These naming point nodes are named
+   by the simplest decimal representation of the socket domain number,
+   for example "/servers/socket/3".
+
+   Socket servers are assumed not to change very often.
+   The library keeps all the server socket ports it has ever looked up,
+   and does not look them up in /servers/socket more than once.  */
+
+socket_t
+_hurd_socket_server (int domain, int dead)
+{
+  socket_t server;
+
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&lock);
+
+  if (domain > max_domain)
+    {
+      error_t save = errno;
+      file_t *new = realloc (servers, (domain + 1) * sizeof (file_t));
+      if (new != NULL)
+	{
+	  while (max_domain <= domain)
+	    new[max_domain++] = MACH_PORT_NULL;
+	  servers = new;
+	}
+      else
+	/* No space to cache the port; we will just fetch it anew below.  */
+	errno = save;
+    }
+
+  if (dead && domain <= max_domain)
+    {
+      /* The user says the port we returned earlier (now in SERVERS[DOMAIN])
+	 was dead.  Clear the cache and fetch a new one below.  */
+      __mach_port_deallocate (__mach_task_self (), servers[domain]);
+      servers[domain] = MACH_PORT_NULL;
+    }
+
+  if (domain > max_domain || servers[domain] == MACH_PORT_NULL)
+    {
+      char name[sizeof (_SERVERS_SOCKET) + 100];
+      char *np = &name[sizeof (name)];
+      *--np = '\0';
+      np = _itoa (domain, np, 10, 0);
+      *--np = '/';
+      np -= sizeof (_SERVERS_SOCKET) - 1;
+      memcpy (np, _SERVERS_SOCKET, sizeof (_SERVERS_SOCKET) - 1);
+      server = __file_name_lookup (np, 0, 0);
+      if (domain <= max_domain)
+	servers[domain] = server;
+    }
+  else
+    server = servers[domain];
+
+  if (server == MACH_PORT_NULL && errno == ENOENT)
+    /* If the server node is absent, we don't support that protocol.  */
+    errno = EPFNOSUPPORT;
+
+  __mutex_unlock (&lock);
+  HURD_CRITICAL_END;
+
+  return server;
+}
+
+static void
+init (void)
+{
+  size_t i;
+
+  __mutex_init (&lock);
+
+  for (i = 0; i < max_domain; ++i)
+    servers[i] = MACH_PORT_NULL;
+
+  (void) &init;			/* Avoid "defined but not used" warning.  */
+}
+text_set_element (_hurd_preinit_hook, init);
diff --git a/hurd/intern-fd.c b/hurd/intern-fd.c
new file mode 100644
index 0000000..fe7424b
--- /dev/null
+++ b/hurd/intern-fd.c
@@ -0,0 +1,50 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/fd.h>
+
+/* Allocate a new file descriptor and install PORT in it.  FLAGS are as for
+   `open'; only O_IGNORE_CTTY is meaningful.
+
+   If the descriptor table is full, set errno, and return -1.
+   If DEALLOC is nonzero, deallocate PORT first.  */
+int
+_hurd_intern_fd (io_t port, int flags, int dealloc)
+{
+  int fd;
+  struct hurd_fd *d;
+
+  HURD_CRITICAL_BEGIN;
+  d = _hurd_alloc_fd (&fd, 0);
+  if (d != NULL)
+    {
+      _hurd_port2fd (d, port, flags);
+      __spin_unlock (&d->port.lock);
+    }
+  HURD_CRITICAL_END;
+
+  if (d == NULL)
+    {
+      if (dealloc)
+	__mach_port_deallocate (__mach_task_self (), port);
+      return -1;
+    }
+
+  return fd;
+}
diff --git a/hurd/intr-rpc.awk b/hurd/intr-rpc.awk
new file mode 100644
index 0000000..9dbcd6f
--- /dev/null
+++ b/hurd/intr-rpc.awk
@@ -0,0 +1,45 @@
+# Icky intimate knowledge of MiG output.
+
+BEGIN \
+  {
+    nprotolines=0; proto=0;
+    args=""; echo=1; isintr=0;
+    intrcall = "__hurd_intr_rpc_" call;
+    print "#include <hurd/signal.h>";
+  }
+
+$NF == intrcall { isintr=1; }
+
+NF == 1 && $1 == ")" { proto=0; }
+proto \
+  {
+    protolines[nprotolines++] = $0;
+    arg = $NF;
+    if (substr(arg, 1, 1) == "*")
+      arg = substr(arg, 2, length(arg)-1);
+    args = args arg;
+  }
+NF == 1 && $1 == "(" { proto=1; }
+
+NF == 3 && $1 == "InP->Head.msgh_request_port" \
+  { portarg = substr($3, 1, length($3)-1); }
+
+{ print $0; }
+
+END \
+  {
+    if (isintr)
+      {
+	print "\n\n/* User-callable interrupt-handling stub.  */";
+	print "kern_return_t __" call;
+	print "(";
+	for (i = 0; i < nprotolines; ++i)
+	  print protolines[i];
+	print ")";
+	print "{";
+	print "  return HURD_EINTR_RPC (" portarg ", " \
+	  intrcall "(" args "));";
+	print "}";
+      }
+    print "weak_alias (__" call ", " call ")"
+  }
diff --git a/hurd/intr-rpc.defs b/hurd/intr-rpc.defs
new file mode 100644
index 0000000..a2e7b06
--- /dev/null
+++ b/hurd/intr-rpc.defs
@@ -0,0 +1,27 @@
+/* Special MiG definitions for interruptible RPC stubs.
+Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+/* Set the MiG options for an interruptible RPC interface.
+   We rename each MiG-generated function to hurd_intr_rpc_CALL and
+   give it the option to return on an interrupted message send.  */
+
+#define INTR_INTERFACE \
+msgoption MACH_SEND_INTERRUPT;\
+userprefix hurd_intr_rpc_;
+
diff --git a/hurd/invoke-trans.c b/hurd/invoke-trans.c
new file mode 100644
index 0000000..e11bff5
--- /dev/null
+++ b/hurd/invoke-trans.c
@@ -0,0 +1,37 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/fs.h>
+
+error_t
+__hurd_invoke_translator (file_t file, int flags, file_t *newport)
+{
+  error_t err;
+  enum retry_type doretry;
+  char retryname[1024];		/* XXX string_t LOSES! */
+
+  err = __file_invoke_translator (file, flags, &doretry, retryname, newport);
+
+  if (! err)
+    err = __USEPORT (CRDIR, __hurd_file_name_lookup_retry (port,
+							   doretry, retryname,
+							   flags, 0, newport));
+
+  return err;
+}
diff --git a/hurd/msgportdemux.c b/hurd/msgportdemux.c
new file mode 100644
index 0000000..ae783ef
--- /dev/null
+++ b/hurd/msgportdemux.c
@@ -0,0 +1,66 @@
+/* Demux messages sent on the signal port.
+
+Copyright (C) 1991, 1992, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/signal.h>
+#include <stddef.h>
+
+struct demux
+  {
+    struct demux *next;
+    boolean_t (*demux) (mach_msg_header_t *inp,
+			mach_msg_header_t *outp);
+  };
+
+struct demux *_hurd_msgport_demuxers = NULL;
+
+extern boolean_t __msg_server (mach_msg_header_t *inp,
+			       mach_msg_header_t *outp);
+
+static boolean_t
+msgport_server (mach_msg_header_t *inp,
+		mach_msg_header_t *outp)
+{
+  extern boolean_t _S_msg_server (mach_msg_header_t *inp,
+				  mach_msg_header_t *outp);
+  extern boolean_t _S_exc_server (mach_msg_header_t *inp,
+				  mach_msg_header_t *outp);
+  struct demux *d;
+
+  for (d = _hurd_msgport_demuxers; d != NULL; d = d->next)
+    if ((*d->demux) (inp, outp))
+      return 1;
+
+  return (_S_exc_server (inp, outp) ||
+	  _S_msg_server (inp, outp));
+}
+
+/* This is the code that the signal thread runs.  */
+void
+_hurd_msgport_receive (void)
+{
+  /* Get our own sigstate cached so we never again have to take a lock to
+     fetch it.  There is much code in hurdsig.c that operates with some
+     sigstate lock held, which will deadlock with _hurd_thread_sigstate.  */
+  (void) _hurd_self_sigstate ();
+
+  while (1)
+    (void) __mach_msg_server (msgport_server, __vm_page_size, _hurd_msgport);
+}
diff --git a/hurd/msgstub.c b/hurd/msgstub.c
new file mode 100644
index 0000000..d4b59ed
--- /dev/null
+++ b/hurd/msgstub.c
@@ -0,0 +1,26 @@
+#include <hurd.h>
+
+/* XXX */
+#define STUB(fn) error_t fn (mach_port_t port) { return EOPNOTSUPP; }
+
+STUB(_S_get_init_ports)
+STUB(_S_set_init_ports)
+STUB(_S_get_init_port)
+STUB(_S_set_init_port)
+STUB(_S_get_init_ints)
+STUB(_S_set_init_ints)
+STUB(_S_get_init_int)
+STUB(_S_set_init_int)
+STUB(_S_get_dtable)
+STUB(_S_set_dtable)
+STUB(_S_get_fd)
+STUB(_S_set_fd)
+STUB(_S_get_environment)
+STUB(_S_set_environment)
+STUB(_S_get_env_variable)
+STUB(_S_set_env_variable)
+STUB(_S_io_select_done)
+STUB(_S_startup_dosync)
+
+STUB(_S_dir_changed)
+STUB(_S_file_changed)
diff --git a/hurd/new-fd.c b/hurd/new-fd.c
new file mode 100644
index 0000000..de9a393
--- /dev/null
+++ b/hurd/new-fd.c
@@ -0,0 +1,39 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd/fd.h>
+#include <stdlib.h>
+#include "hurdmalloc.h"		/* XXX */
+
+/* Allocate a new file descriptor structure 
+   and initialize it with PORT and CTTY.  */
+
+struct hurd_fd *
+_hurd_new_fd (io_t port, io_t ctty)
+{
+  struct hurd_fd *d = malloc (sizeof (struct hurd_fd));
+
+  if (d != NULL)
+    {
+      /* Initialize the port cells.  */
+      _hurd_port_init (&d->port, port);
+      _hurd_port_init (&d->ctty, ctty);
+    }
+
+  return d;
+}
diff --git a/hurd/openport.c b/hurd/openport.c
new file mode 100644
index 0000000..244368a
--- /dev/null
+++ b/hurd/openport.c
@@ -0,0 +1,29 @@
+/* Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/fd.h>
+
+/* User entry point for interning a port as a new FD.
+   Just like _hurd_intern_fd, but don't dealloc PORT on error.  */
+
+int
+openport (io_t port, int flags)
+{
+  return _hurd_intern_fd (port, flags, 0);
+}
diff --git a/hurd/pid2task.c b/hurd/pid2task.c
new file mode 100644
index 0000000..6b8182b
--- /dev/null
+++ b/hurd/pid2task.c
@@ -0,0 +1,32 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+task_t
+__pid2task (pid_t pid)
+{
+  error_t err;
+  task_t task;
+
+  err = __USEPORT (PROC, __proc_pid2task (port, pid, &task));
+
+  return err ? (__hurd_fail (err), MACH_PORT_NULL) : task;
+}
+
+weak_alias (__pid2task, pid2task)
diff --git a/hurd/port2fd.c b/hurd/port2fd.c
new file mode 100644
index 0000000..cad89e7
--- /dev/null
+++ b/hurd/port2fd.c
@@ -0,0 +1,75 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/fd.h>
+#include <hurd/signal.h>
+#include <hurd/term.h>
+#include <fcntl.h>
+
+/* Store PORT in file descriptor D, doing appropriate ctty magic.
+   FLAGS are as for `open'; only O_IGNORE_CTTY is meaningful.
+   D should be locked, and will not be unlocked.  */
+
+void
+_hurd_port2fd (struct hurd_fd *d, io_t port, int flags)
+{
+  io_t ctty;
+  mach_port_t cttyid;
+  int is_ctty = !(flags & O_IGNORE_CTTY) && ! __term_getctty (port, &cttyid);
+
+  if (is_ctty)
+    {
+      /* This port is capable of being a controlling tty.
+	 Is it ours?  */
+      struct hurd_port *const id = &_hurd_ports[INIT_PORT_CTTYID];
+      __spin_lock (&id->lock);
+      if (id->port == MACH_PORT_NULL)
+	/* We have no controlling tty, so make this one it.  */
+	_hurd_port_locked_set (id, cttyid);
+      else
+	{
+	  if (cttyid != id->port)
+	    /* We have a controlling tty and this is not it.  */
+	    is_ctty = 0;
+	  /* Either we don't want CTTYID, or ID->port already is it.
+	     So we don't need to change ID->port, and we can release
+	     the reference to CTTYID.  */
+	  __spin_unlock (&id->lock);
+	  __mach_port_deallocate (__mach_task_self (), cttyid);
+	}
+    }
+
+  if (!is_ctty || __term_open_ctty (port, _hurd_pid, _hurd_pgrp, &ctty) != 0)
+    /* XXX if IS_CTTY, then this port is our ctty, but we are
+       not doing ctty style i/o because term_become_ctty barfed.
+       What to do?  */
+    /* No ctty magic happening here.  */
+    ctty = MACH_PORT_NULL;
+
+  /* Install PORT in the descriptor cell, leaving it locked.  */
+  {
+    mach_port_t old
+      = _hurd_userlink_clear (&d->port.users) ? d->port.port : MACH_PORT_NULL;
+    d->port.port = port;
+    if (old != MACH_PORT_NULL)
+      __mach_port_deallocate (__mach_task_self (), old);
+  }
+
+  _hurd_port_set (&d->ctty, ctty);
+}
diff --git a/hurd/ports-get.c b/hurd/ports-get.c
new file mode 100644
index 0000000..def5973
--- /dev/null
+++ b/hurd/ports-get.c
@@ -0,0 +1,46 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+static error_t
+getbootstrap (mach_port_t *result)
+{
+  return __task_get_special_port (__mach_task_self (),
+				  TASK_BOOTSTRAP_PORT,
+				  result);
+}
+
+error_t (*_hurd_ports_getters[INIT_PORT_MAX]) (mach_port_t *result) =
+  {
+    [INIT_PORT_BOOTSTRAP] = getbootstrap,
+  };
+
+error_t
+_hurd_ports_get (int which, mach_port_t *result)
+{
+  if (which < 0 || which >= _hurd_nports)
+    return EINVAL;
+  if (which >= INIT_PORT_MAX || _hurd_ports_getters[which] == NULL)
+    return HURD_PORT_USE (&_hurd_ports[which],
+			  __mach_port_mod_refs (__mach_task_self (),
+						(*result = port),
+						MACH_PORT_RIGHT_SEND,
+						+1));
+  return (*_hurd_ports_getters[which]) (result);
+}
diff --git a/hurd/ports-set.c b/hurd/ports-set.c
new file mode 100644
index 0000000..fbc2940
--- /dev/null
+++ b/hurd/ports-set.c
@@ -0,0 +1,57 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+static error_t
+setbootstrap (mach_port_t newport)
+{
+  return __task_set_special_port (__mach_task_self (),
+				  TASK_BOOTSTRAP_PORT,
+				  newport);
+}
+
+extern error_t _hurd_setauth (auth_t);
+extern error_t _hurd_setproc (process_t);
+extern error_t _hurd_setcttyid (mach_port_t);
+
+error_t (*_hurd_ports_setters[INIT_PORT_MAX]) (mach_port_t newport) =
+  {
+    [INIT_PORT_BOOTSTRAP] = setbootstrap,
+    [INIT_PORT_AUTH] = _hurd_setauth,
+    [INIT_PORT_PROC] = _hurd_setproc,
+    [INIT_PORT_CTTYID] = _hurd_setcttyid,
+  };
+
+
+error_t
+_hurd_ports_set (int which, mach_port_t newport)
+{
+  error_t err;
+  if (which < 0 || which >= _hurd_nports)
+    return EINVAL;
+  if (err = __mach_port_mod_refs (__mach_task_self (), newport,
+				  MACH_PORT_RIGHT_SEND, 1))
+    return err;
+  if (which >= INIT_PORT_MAX || _hurd_ports_setters[which] == NULL)
+    {
+      _hurd_port_set (&_hurd_ports[which], newport);
+      return 0;
+    }
+  return (*_hurd_ports_setters[which]) (newport);
+}
diff --git a/hurd/preempt-sig.c b/hurd/preempt-sig.c
new file mode 100644
index 0000000..8676196
--- /dev/null
+++ b/hurd/preempt-sig.c
@@ -0,0 +1,68 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd/signal.h>
+
+/* Initialize PREEMPTER with the information given and stick it in the
+   chain of preempters for SIGNO.  */
+
+int
+hurd_preempt_signals (struct hurd_signal_preempt *preempter,
+		      int signo, int first_code, int last_code,
+		      sighandler_t (*handler) (thread_t, int, long int, int))
+{
+  if (signo <= 0 || signo >= NSIG)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  preempter->first = first_code;
+  preempter->last = last_code;
+  preempter->handler = handler;
+  __mutex_lock (&_hurd_signal_preempt_lock);
+  preempter->next = _hurd_signal_preempt[signo];
+  _hurd_signal_preempt[signo] = preempter;
+  __mutex_unlock (&_hurd_signal_preempt_lock);
+  return 0;
+}
+
+/* Remove PREEMPTER from the chain for SIGNO.  */
+
+int
+hurd_unpreempt_signals (struct hurd_signal_preempt *preempter, int signo)
+{
+  struct hurd_signal_preempt *p, *lastp;
+  if (signo <= 0 || signo >= NSIG)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  __mutex_lock (&_hurd_signal_preempt_lock);
+  for (p = _hurd_signal_preempt[signo], lastp = NULL;
+       p != NULL; lastp = p, p = p->next)
+    if (p == preempter)
+      {
+	(lastp == NULL ? _hurd_signal_preempt[signo] : lastp->next) = p->next;
+	__mutex_unlock (&_hurd_signal_preempt_lock);
+	return 0;
+      }
+  _hurd_signal_preempt[signo] = preempter;
+  __mutex_unlock (&_hurd_signal_preempt_lock);
+  errno = ENOENT;
+  return -1;
+}
diff --git a/hurd/privports.c b/hurd/privports.c
new file mode 100644
index 0000000..f760e37
--- /dev/null
+++ b/hurd/privports.c
@@ -0,0 +1,60 @@
+/* Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+/* The program might set these if it is the initial task
+   bootstrapped by the microkernel.  */
+
+mach_port_t _hurd_host_priv, _hurd_device_master;
+
+
+kern_return_t
+get_privileged_ports (host_priv_t *host_priv_ptr, device_t *device_master_ptr)
+{
+  if (! _hurd_host_priv)
+    {
+      error_t err;
+
+      if (_hurd_ports)
+	/* We have gotten some initial ports, so perhaps
+	   we have a proc server to talk to.  */
+	err = __USEPORT (PROC, __proc_getprivports (port,
+						    &_hurd_host_priv,
+						    &_hurd_device_master));
+      else
+	return MACH_SEND_INVALID_DEST;
+
+      if (err)
+	return err;
+    }
+
+  if (host_priv_ptr)
+    {
+      mach_port_mod_refs (mach_task_self (),
+			  _hurd_host_priv, MACH_PORT_RIGHT_SEND, 1);
+      *host_priv_ptr = _hurd_host_priv;
+    }
+  if (device_master_ptr)
+    {
+      mach_port_mod_refs (mach_task_self (),
+			  _hurd_device_master, MACH_PORT_RIGHT_SEND, 1);
+      *device_master_ptr = _hurd_device_master;
+    }
+  return KERN_SUCCESS;
+}
diff --git a/hurd/setauth.c b/hurd/setauth.c
new file mode 100644
index 0000000..7378e4f
--- /dev/null
+++ b/hurd/setauth.c
@@ -0,0 +1,124 @@
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/port.h>
+#include <hurd/id.h>
+#include "set-hooks.h"
+
+/* Things in the library which want to be run when the auth port changes.  */
+DEFINE_HOOK (_hurd_reauth_hook, (auth_t new_auth));
+
+#include <cthreads.h>
+static struct mutex reauth_lock = MUTEX_INITIALIZER;
+
+
+/* Set the auth port to NEW, and reauthenticate
+   everything used by the library.  */
+error_t
+_hurd_setauth (auth_t new)
+{
+  error_t err;
+  int d;
+  mach_port_t newport, ref;
+
+  /* Give the new send right a user reference.
+     This is a good way to check that it is valid.  */
+  if (err = __mach_port_mod_refs (__mach_task_self (), new,
+				  MACH_PORT_RIGHT_SEND, 1))
+    return err;
+
+  HURD_CRITICAL_BEGIN;
+
+  /* We lock against another thread doing setauth.  Anyone who sets
+     _hurd_ports[INIT_PORT_AUTH] some other way is asking to lose.  */
+  __mutex_lock (&reauth_lock);
+
+  /* Install the new port in the cell.  */
+  __mutex_lock (&_hurd_id.lock);
+  _hurd_port_set (&_hurd_ports[INIT_PORT_AUTH], new);
+  _hurd_id.valid = 0;
+  if (_hurd_id.rid_auth)
+    {
+      __mach_port_deallocate (__mach_task_self (), _hurd_id.rid_auth);
+      _hurd_id.rid_auth = MACH_PORT_NULL;
+    }
+  __mutex_unlock (&_hurd_id.lock);
+
+  if (_hurd_init_dtable != NULL)
+    /* We just have the simple table we got at startup.
+       Otherwise, a reauth_hook in dtable.c takes care of this.  */
+    for (d = 0; d < _hurd_init_dtablesize; ++d)
+      if (_hurd_init_dtable[d] != MACH_PORT_NULL)
+	{
+	  mach_port_t new;
+	  ref = __mach_reply_port ();
+	  if (! __io_reauthenticate (_hurd_init_dtable[d],
+				     ref, MACH_MSG_TYPE_MAKE_SEND) &&
+	      ! HURD_PORT_USE (&_hurd_ports[INIT_PORT_AUTH],
+			       __auth_user_authenticate
+			       (port,
+				_hurd_init_dtable[d],
+				ref, MACH_MSG_TYPE_MAKE_SEND,
+				&new)))
+	    {
+	      __mach_port_deallocate (__mach_task_self (),
+				      _hurd_init_dtable[d]);
+	      _hurd_init_dtable[d] = new;
+	    }
+	  __mach_port_destroy (__mach_task_self (), ref);
+	}
+
+  ref = __mach_reply_port ();
+  if (__USEPORT (CRDIR,
+		 ! __io_reauthenticate (port,
+					ref, MACH_MSG_TYPE_MAKE_SEND) &&
+		 ! __auth_user_authenticate (new, port,
+					     ref, MACH_MSG_TYPE_MAKE_SEND,
+					     &newport)))
+    _hurd_port_set (&_hurd_ports[INIT_PORT_CRDIR], newport);
+  __mach_port_destroy (__mach_task_self (), ref);
+
+  ref = __mach_reply_port ();
+  if (__USEPORT (CWDIR,
+		 ! __io_reauthenticate (port,
+					ref, MACH_MSG_TYPE_MAKE_SEND) &&
+		 ! __auth_user_authenticate (new, port,
+					     ref, MACH_MSG_TYPE_MAKE_SEND,
+					     &newport)))
+    _hurd_port_set (&_hurd_ports[INIT_PORT_CWDIR], newport);
+  __mach_port_destroy (__mach_task_self (), ref);
+
+  /* Run things which want to do reauthorization stuff.  */
+  RUN_HOOK (_hurd_reauth_hook, (new));
+
+  __mutex_unlock (&reauth_lock);
+
+  HURD_CRITICAL_END;
+
+  return 0;
+}
+
+int
+__setauth (auth_t new)
+{
+  error_t err = _hurd_setauth (new);
+  return err ? __hurd_fail (err) : 0;
+}
+
+weak_alias (__setauth, setauth)
diff --git a/hurd/setuids.c b/hurd/setuids.c
new file mode 100644
index 0000000..3b049b0
--- /dev/null
+++ b/hurd/setuids.c
@@ -0,0 +1,59 @@
+/* Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+#include <hurd/id.h>
+
+/* Set the uid set for the current user to UIDS (N of them).  */
+int
+setuids (int n, const uid_t *uids)
+{
+  error_t err;
+  auth_t newauth;
+  size_t i;
+  gid_t new[n];
+
+  /* Fault before taking locks.  */
+  for (i = 0; i < n; ++i)
+    new[i] = uids[i];
+
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&_hurd_id.lock);
+  err = _hurd_check_ids ();
+  if (! err)
+    {
+      /* Get a new auth port using those IDs.  */
+      err = __USEPORT (AUTH,
+		       __auth_makeauth (port, NULL, 0, 0,
+					new, n,
+					_hurd_id.aux.uids, _hurd_id.aux.nuids,
+					_hurd_id.gen.gids, _hurd_id.gen.ngids,
+					_hurd_id.aux.gids, _hurd_id.aux.ngids,
+					&newauth));
+    }
+  __mutex_unlock (&_hurd_id.lock);
+  HURD_CRITICAL_END;
+
+  if (err)
+    return __hurd_fail (err);
+
+  /* Install the new auth port and reauthenticate everything.  */
+  err = __setauth (newauth);
+  __mach_port_deallocate (__mach_task_self (), newauth);
+  return err;
+}
diff --git a/hurd/siginfo.c b/hurd/siginfo.c
new file mode 100644
index 0000000..eb61fec
--- /dev/null
+++ b/hurd/siginfo.c
@@ -0,0 +1,27 @@
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd/signal.h>
+#include <stdio.h>
+
+void
+_hurd_siginfo_handler (int signo)
+{
+  /* XXX */
+  puts ("got a SIGINFO");
+}
diff --git a/hurd/task2pid.c b/hurd/task2pid.c
new file mode 100644
index 0000000..707753c
--- /dev/null
+++ b/hurd/task2pid.c
@@ -0,0 +1,30 @@
+/* Copyright (C) 1991, 1992, 1993, 1995 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <hurd.h>
+
+pid_t
+__task2pid (task_t task)
+{
+  error_t err;
+  pid_t pid;
+  err = __USEPORT (PROC, __proc_task2pid (port, task, &pid));
+  return err ? (pid_t) __hurd_fail (err) : pid;
+}
+
+weak_alias (__task2pid, task2pid)
diff --git a/hurd/vpprintf.c b/hurd/vpprintf.c
new file mode 100644
index 0000000..dcdcd5a
--- /dev/null
+++ b/hurd/vpprintf.c
@@ -0,0 +1,60 @@
+/* Copyright (C) 1991, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+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., 675 Mass Ave,
+Cambridge, MA 02139, USA.  */
+
+#include <ansidecl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <hurd.h>
+
+static ssize_t
+DEFUN(pwrite, (cookie, buf, n),
+      PTR cookie AND CONST char *buf AND size_t n)
+{
+  error_t error = __io_write ((io_t) cookie, buf, n, -1,
+			      (mach_msg_type_number_t *) &n);
+  if (error)
+    return __hurd_fail (error);
+  return n;
+}
+
+
+/* Write formatted output to PORT, a Mach port supporting the i/o protocol,
+   according to the format string FORMAT, using the argument list in ARG.  */
+int
+DEFUN(vpprintf, (port, format, arg),
+      io_t port AND CONST char *format AND va_list arg)
+{
+  int done;
+  FILE f;
+
+  /* Create an unbuffered stream talking to PORT on the stack.  */
+  memset((PTR) &f, 0, sizeof(f));
+  f.__magic = _IOMAGIC;
+  f.__mode.__write = 1;
+  f.__cookie = (PTR) port;
+  f.__room_funcs = __default_room_functions;
+  f.__io_funcs.__write = pwrite;
+  f.__seen = 1;
+  f.__userbuf = 1;
+
+  /* vfprintf will use a buffer on the stack for the life of the call.  */
+  done = vfprintf(&f, format, arg);
+
+  return done;
+}