hurd/hurdioctl.c

   1 /* ioctl commands which must be done in the C library.
   2 Copyright (C) 1994, 1995 Free Software Foundation, Inc.
   3 This file is part of the GNU C Library.
   4
   5 The GNU C Library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Library General Public License as
   7 published by the Free Software Foundation; either version 2 of the
   8 License, or (at your option) any later version.
   9
  10 The GNU C Library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with the GNU C Library; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, USA.  */
  19
  20 #include <hurd.h>
  21 #include <hurd/fd.h>
  22 #include <sys/ioctl.h>
  23 #include <hurd/ioctl.h>
  24
  25
  26
  27 /* Symbol set of ioctl handler lists.  If there are user-registered
  28    handlers, one of these lists will contain them.  The other lists are
  29    handlers built into the library.  */
  30 symbol_set_define (_hurd_ioctl_handler_lists)
  31
  32 /* Look up REQUEST in the set of handlers.  */
  33 ioctl_handler_t
  34 _hurd_lookup_ioctl_handler (int request)
  35 {
  36   void *const *ptr;
  37   const struct ioctl_handler *h;
  38
  39   for (ptr = symbol_set_first_element (_hurd_ioctl_handler_lists);
  40        !symbol_set_end_p (_hurd_ioctl_handler_lists, ptr);
  41        ++ptr)
  42     for (h = *ptr; h != NULL; h = h->next)
  43       if (request >= h->first_request && request <= h->last_request)
  44         return h->handler;
  45
  46   return NULL;
  47 }
  48 \f
  49 #include <fcntl.h>
  50
  51 /* Find out how many bytes may be read from FD without blocking.  */
  52
  53 static int
  54 fioctl (int fd,
  55         int request,
  56         int *arg)
  57 {
  58   error_t err;
  59
  60   *(volatile int *) arg = *arg;
  61
  62   switch (request)
  63     {
  64     default:
  65       err = EGRATUITOUS;
  66       break;
  67
  68     case FIONREAD:
  69       {
  70         mach_msg_type_number_t navail;
  71         err = HURD_DPORT_USE (fd, __io_readable (port, &navail));
  72         if (!err)
  73           *arg = (int) navail;
  74       }
  75       break;
  76
  77     case FIONBIO:
  78       err = HURD_DPORT_USE (fd, (*arg ?
  79                                  __io_set_some_openmodes :
  80                                  __io_clear_some_openmodes)
  81                             (port, O_NONBLOCK));
  82       break;
  83
  84     case FIOASYNC:
  85       err = HURD_DPORT_USE (fd, (*arg ?
  86                                  __io_set_some_openmodes :
  87                                  __io_clear_some_openmodes)
  88                             (port, O_ASYNC));
  89       break;
  90
  91     case FIOSETOWN:
  92       err = HURD_DPORT_USE (fd, __io_mod_owner (port, *arg));
  93       break;
  94
  95     case FIOGETOWN:
  96       err = HURD_DPORT_USE (fd, __io_get_owner (port, arg));
  97       break;
  98     }
  99
 100   return err ? __hurd_fail (err) : 0;
 101 }
 102
 103 _HURD_HANDLE_IOCTLS (fioctl, FIOGETOWN, FIONREAD);
 104
 105
 106 static int
 107 fioclex (int fd,
 108          int request)
 109 {
 110   int flag;
 111
 112   switch (request)
 113     {
 114     default:
 115       return __hurd_fail (EGRATUITOUS);
 116     case FIOCLEX:
 117       flag = FD_CLOEXEC;
 118       break;
 119     case FIONCLEX:
 120       flag = 0;
 121       break;
 122     }
 123
 124   return __fcntl (fd, F_SETFD, flag);
 125 }
 126 _HURD_HANDLE_IOCTLS (fioclex, FIOCLEX, FIONCLEX);
 127 \f
 128 #include <hurd/term.h>
 129
 130 static void
 131 rectty_dtable (mach_port_t cttyid)
 132 {
 133   int i;
 134
 135   HURD_CRITICAL_BEGIN;
 136   __mutex_lock (&_hurd_dtable_lock);
 137
 138   for (i = 0; i < _hurd_dtablesize; ++i)
 139     {
 140       struct hurd_fd *const d = _hurd_dtable[i];
 141       mach_port_t newctty;
 142
 143       if (d == NULL)
 144         /* Nothing to do for an unused descriptor cell.  */
 145         continue;
 146
 147       if (cttyid == MACH_PORT_NULL)
 148         /* We now have no controlling tty at all.  */
 149         newctty = MACH_PORT_NULL;
 150       else
 151         HURD_PORT_USE (&d->port,
 152                        ({ mach_port_t id;
 153                           /* Get the io object's cttyid port.  */
 154                           if (! __term_getctty (port, &id))
 155                             {
 156                               if (id == cttyid && /* Is it ours?  */
 157                                   /* Get the ctty io port.  */
 158                                   __term_open_ctty (port,
 159                                                     _hurd_pid, _hurd_pgrp,
 160                                                     &newctty))
 161                                 /* XXX it is our ctty but the call failed? */
 162                                 newctty = MACH_PORT_NULL;
 163                               __mach_port_deallocate
 164                                 (__mach_task_self (), (mach_port_t) id);
 165                             }
 166                           else
 167                             newctty = MACH_PORT_NULL;
 168                           0;
 169                         }));
 170
 171       /* Install the new ctty port.  */
 172       _hurd_port_set (&d->ctty, newctty);
 173     }
 174
 175   __mutex_unlock (&_hurd_dtable_lock);
 176   HURD_CRITICAL_END;
 177 }
 178
 179
 180 /* Called when we have received a message saying to use a new ctty ID port.  */
 181
 182 error_t
 183 _hurd_setcttyid (mach_port_t cttyid)
 184 {
 185   error_t err;
 186
 187   if (cttyid != MACH_PORT_NULL)
 188     {
 189       /* Give the new send right a user reference.
 190          This is a good way to check that it is valid.  */
 191       if (err = __mach_port_mod_refs (__mach_task_self (), cttyid,
 192                                       MACH_PORT_RIGHT_SEND, 1))
 193         return err;
 194     }
 195
 196   /* Install the port, consuming the reference we just created.  */
 197   _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], cttyid);
 198
 199   /* Reset all the ctty ports in all the descriptors.  */
 200   __USEPORT (CTTYID, (rectty_dtable (cttyid), 0));
 201
 202   return 0;
 203 }
 204
 205
 206 /* Make FD be the controlling terminal.
 207    This function is called for `ioctl (fd, TCIOSCTTY)'.  */
 208
 209 static int
 210 tiocsctty (int fd,
 211            int request)         /* Always TIOCSCTTY.  */
 212 {
 213   mach_port_t cttyid;
 214   error_t err;
 215
 216   /* Get FD's cttyid port, unless it is already ours.  */
 217   err = HURD_DPORT_USE (fd, ctty != MACH_PORT_NULL ? EADDRINUSE :
 218                         __term_getctty (port, &cttyid));
 219   if (err == EADDRINUSE)
 220     /* FD is already the ctty.  Nothing to do.  */
 221     return 0;
 222   else if (err)
 223     return __hurd_fail (err);
 224
 225   /* Make it our own.  */
 226   _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], cttyid);
 227
 228   /* Reset all the ctty ports in all the descriptors.  */
 229   __USEPORT (CTTYID, (rectty_dtable (cttyid), 0));
 230
 231   return 0;
 232 }
 233 _HURD_HANDLE_IOCTL (tiocsctty, TIOCSCTTY);
 234
 235 /* Dissociate from the controlling terminal.  */
 236
 237 static int
 238 tiocnotty (int fd,
 239            int request)         /* Always TIOCNOTTY.  */
 240 {
 241   mach_port_t fd_cttyid;
 242   error_t err;
 243
 244   if (err = HURD_DPORT_USE (fd, __term_getctty (port, &fd_cttyid)))
 245     return __hurd_fail (err);
 246
 247   if (__USEPORT (CTTYID, port != fd_cttyid))
 248     err = EINVAL;
 249
 250   __mach_port_deallocate (__mach_task_self (), fd_cttyid);
 251
 252   if (err)
 253     return __hurd_fail (err);
 254
 255   /* Clear our cttyid port cell.  */
 256   _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], MACH_PORT_NULL);
 257
 258   /* Reset all the ctty ports in all the descriptors.  */
 259
 260   __USEPORT (CTTYID, (rectty_dtable (MACH_PORT_NULL), 0));
 261
 262   return 0;
 263 }
 264 _HURD_HANDLE_IOCTL (tiocnotty, TIOCNOTTY);