Don't install sys/xattr.h
[kopensolaris-gnu/glibc.git] / hurd / hurdioctl.c
index a65a530..96d910b 100644 (file)
@@ -1,35 +1,54 @@
 /* ioctl commands which must be done in the C library.
-Copyright (C) 1994 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+   Copyright (C) 1994,95,96,97,99,2001,02 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 free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
-The GNU C Library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Library General Public License for more details.
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
 
-You should have received a copy of the GNU 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.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 #include <hurd.h>
 #include <hurd/fd.h>
 #include <sys/ioctl.h>
-#include <gnu-stabs.h>
+#include <hurd/ioctl.h>
+#include <string.h>
 
-/* Symbol set of ioctl handler lists.  This definition is here so that when
-   __ioctl refers to it, we will link in fionread et al (below).  */
 
-const struct
-  {
-    size_t n;
-    struct ioctl_handler *v[0];
-  } _hurd_ioctl_handler_lists;
+/* 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;
+
+  /* Mask off the type bits, so that we see requests in a single group as a
+     contiguous block of values.  */
+  request = _IOC_NOTYPE (request);
+
+  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;
+}
 \f
 #include <fcntl.h>
 
@@ -47,11 +66,16 @@ fioctl (int fd,
   switch (request)
     {
     default:
-      err = EGRATUITOUS;
+      err = ENOTTY;
       break;
 
     case FIONREAD:
-      err = HURD_DPORT_USE (fd, __io_readable (port, arg));
+      {
+       mach_msg_type_number_t navail;
+       err = HURD_DPORT_USE (fd, __io_readable (port, &navail));
+       if (!err)
+         *arg = (int) navail;
+      }
       break;
 
     case FIONBIO:
@@ -77,7 +101,7 @@ fioctl (int fd,
       break;
     }
 
-  return err ? __hurd_fail (err) : 0;
+  return err ? __hurd_dfail (fd, err) : 0;
 }
 
 _HURD_HANDLE_IOCTLS (fioctl, FIOGETOWN, FIONREAD);
@@ -92,7 +116,7 @@ fioclex (int fd,
   switch (request)
     {
     default:
-      return __hurd_fail (EGRATUITOUS);
+      return __hurd_fail (ENOTTY);
     case FIOCLEX:
       flag = FD_CLOEXEC;
       break;
@@ -106,14 +130,41 @@ fioclex (int fd,
 _HURD_HANDLE_IOCTLS (fioclex, FIOCLEX, FIONCLEX);
 \f
 #include <hurd/term.h>
+#include <hurd/tioctl.h>
 
-static void
-rectty_dtable (mach_port_t cttyid)
+/* Install a new CTTYID port, atomically updating the dtable appropriately.
+   This consumes the send right passed in.  */
+
+void
+_hurd_locked_install_cttyid (mach_port_t cttyid)
 {
+  mach_port_t old;
+  struct hurd_port *const port = &_hurd_ports[INIT_PORT_CTTYID];
+  struct hurd_userlink ulink;
   int i;
-  
-  HURD_CRITICAL_BEGIN;
-  __mutex_lock (&_hurd_dtable_lock);
+
+  /* Install the new cttyid port, and preserve it with a ulink.
+     We unroll the _hurd_port_set + _hurd_port_get here so that
+     there is no window where the cell is unlocked and CTTYID could
+     be changed by another thread.  (We also delay the deallocation
+     of the old port until the end, to minimize the duration of the
+     critical section.)
+
+     It is important that changing the cttyid port is only ever done by
+     holding the dtable lock continuously while updating the port cell and
+     re-ctty'ing the dtable; dtable.c assumes we do this.  Otherwise, the
+     pgrp-change notification code in dtable.c has to worry about racing
+     against us here in odd situations.  The one exception to this is
+     setsid, which holds the dtable lock while changing the pgrp and
+     clearing the cttyid port, and then unlocks the dtable lock to allow
+
+
+  */
+
+  __spin_lock (&port->lock);
+  old = _hurd_userlink_clear (&port->users) ? port->port : MACH_PORT_NULL;
+  port->port = cttyid;
+  cttyid = _hurd_port_locked_get (port, &ulink);
 
   for (i = 0; i < _hurd_dtablesize; ++i)
     {
@@ -135,10 +186,9 @@ rectty_dtable (mach_port_t cttyid)
                            {
                              if (id == cttyid && /* Is it ours?  */
                                  /* Get the ctty io port.  */
-                                 __term_become_ctty (port, _hurd_pid,
-                                                     _hurd_pgrp,
-                                                     _hurd_msgport,
-                                                     &newctty))
+                                 __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
@@ -154,10 +204,45 @@ rectty_dtable (mach_port_t cttyid)
     }
 
   __mutex_unlock (&_hurd_dtable_lock);
+
+  if (old != MACH_PORT_NULL)
+    __mach_port_deallocate (__mach_task_self (), old);
+  _hurd_port_free (port, &ulink, cttyid);
+}
+
+static void
+install_ctty (mach_port_t cttyid)
+{
+  HURD_CRITICAL_BEGIN;
+  __mutex_lock (&_hurd_dtable_lock);
+  _hurd_locked_install_cttyid (cttyid);
   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.  */
+  install_ctty (cttyid);
+
+  return 0;
+}
+
+
 /* Make FD be the controlling terminal.
    This function is called for `ioctl (fd, TCIOSCTTY)'.  */
 
@@ -169,19 +254,21 @@ tiocsctty (int fd,
   error_t err;
 
   /* Get FD's cttyid port, unless it is already ours.  */
-  err = HURD_DPORT_USE (fd,
-                       ctty ? EADDRINUSE : __term_getctty (port, &cttyid));
+  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); /* Consumes ref.  */
+  /* Change the terminal's pgrp to ours.  */
+  err = HURD_DPORT_USE (fd, __tioctl_tiocspgrp (port, _hurd_pgrp));
+  if (err)
+    return __hurd_fail (err);
 
-  /* Reset all the ctty ports in all the descriptors.  */
-  __USEPORT (CTTYID, (rectty_dtable (port), 0));
+  /* Make it our own.  */
+  install_ctty (cttyid);
 
   return 0;
 }
@@ -207,13 +294,38 @@ tiocnotty (int fd,
   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));
+  /* Clear our cttyid port.  */
+  install_ctty (MACH_PORT_NULL);
 
   return 0;
 }
 _HURD_HANDLE_IOCTL (tiocnotty, TIOCNOTTY);
+\f
+#include <hurd/pfinet.h>
+#include <net/if.h>
+#include <netinet/in.h>
+
+/* Fill in the buffer IFC->IFC_BUF of length IFC->IFC_LEN with a list
+   of ifr structures, one for each network interface.  */
+static int
+siocgifconf (int fd, int request, struct ifconf *ifc)
+{
+  error_t err;
+  size_t data_len = ifc->ifc_len;
+  char *data = ifc->ifc_buf;
+
+  if (data_len <= 0)
+    return 0;
+
+  err = HURD_DPORT_USE (fd, __pfinet_siocgifconf (port, ifc->ifc_len,
+                                                 &data, &data_len));
+  if (data_len < ifc->ifc_len)
+    ifc->ifc_len = data_len;
+  if (data != ifc->ifc_buf)
+    {
+      memcpy (ifc->ifc_buf, data, ifc->ifc_len);
+      __vm_deallocate (__mach_task_self (), (vm_address_t) data, data_len);
+    }
+  return err ? __hurd_dfail (fd, err) : 0;
+}
+_HURD_HANDLE_IOCTL (siocgifconf, SIOCGIFCONF);