hurd/hurdioctl.c

   1 /* ioctl commands which must be done in the C library.
   2    Copyright (C) 1994, 1995, 1996, 1997 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 not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, 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   /* Mask off the type bits, so that we see requests in a single group as a
  40      contiguous block of values.  */
  41   request = _IOC_NOTYPE (request);
  42
  43   for (ptr = symbol_set_first_element (_hurd_ioctl_handler_lists);
  44        !symbol_set_end_p (_hurd_ioctl_handler_lists, ptr);
  45        ++ptr)
  46     for (h = *ptr; h != NULL; h = h->next)
  47       if (request >= h->first_request && request <= h->last_request)
  48         return h->handler;
  49
  50   return NULL;
  51 }
  52 \f
  53 #include <fcntl.h>
  54
  55 /* Find out how many bytes may be read from FD without blocking.  */
  56
  57 static int
  58 fioctl (int fd,
  59         int request,
  60         int *arg)
  61 {
  62   error_t err;
  63
  64   *(volatile int *) arg = *arg;
  65
  66   switch (request)
  67     {
  68     default:
  69       err = ENOTTY;
  70       break;
  71
  72     case FIONREAD:
  73       {
  74         mach_msg_type_number_t navail;
  75         err = HURD_DPORT_USE (fd, __io_readable (port, &navail));
  76         if (!err)
  77           *arg = (int) navail;
  78       }
  79       break;
  80
  81     case FIONBIO:
  82       err = HURD_DPORT_USE (fd, (*arg ?
  83                                  __io_set_some_openmodes :
  84                                  __io_clear_some_openmodes)
  85                             (port, O_NONBLOCK));
  86       break;
  87
  88     case FIOASYNC:
  89       err = HURD_DPORT_USE (fd, (*arg ?
  90                                  __io_set_some_openmodes :
  91                                  __io_clear_some_openmodes)
  92                             (port, O_ASYNC));
  93       break;
  94
  95     case FIOSETOWN:
  96       err = HURD_DPORT_USE (fd, __io_mod_owner (port, *arg));
  97       break;
  98
  99     case FIOGETOWN:
 100       err = HURD_DPORT_USE (fd, __io_get_owner (port, arg));
 101       break;
 102     }
 103
 104   return err ? __hurd_dfail (fd, err) : 0;
 105 }
 106
 107 _HURD_HANDLE_IOCTLS (fioctl, FIOGETOWN, FIONREAD);
 108
 109
 110 static int
 111 fioclex (int fd,
 112          int request)
 113 {
 114   int flag;
 115
 116   switch (request)
 117     {
 118     default:
 119       return __hurd_fail (ENOTTY);
 120     case FIOCLEX:
 121       flag = FD_CLOEXEC;
 122       break;
 123     case FIONCLEX:
 124       flag = 0;
 125       break;
 126     }
 127
 128   return __fcntl (fd, F_SETFD, flag);
 129 }
 130 _HURD_HANDLE_IOCTLS (fioclex, FIOCLEX, FIONCLEX);
 131 \f
 132 #include <hurd/term.h>
 133 #include <hurd/tioctl.h>
 134
 135 static void
 136 rectty_dtable (mach_port_t cttyid)
 137 {
 138   int i;
 139
 140   HURD_CRITICAL_BEGIN;
 141   __mutex_lock (&_hurd_dtable_lock);
 142
 143   for (i = 0; i < _hurd_dtablesize; ++i)
 144     {
 145       struct hurd_fd *const d = _hurd_dtable[i];
 146       mach_port_t newctty;
 147
 148       if (d == NULL)
 149         /* Nothing to do for an unused descriptor cell.  */
 150         continue;
 151
 152       if (cttyid == MACH_PORT_NULL)
 153         /* We now have no controlling tty at all.  */
 154         newctty = MACH_PORT_NULL;
 155       else
 156         HURD_PORT_USE (&d->port,
 157                        ({ mach_port_t id;
 158                           /* Get the io object's cttyid port.  */
 159                           if (! __term_getctty (port, &id))
 160                             {
 161                               if (id == cttyid && /* Is it ours?  */
 162                                   /* Get the ctty io port.  */
 163                                   __term_open_ctty (port,
 164                                                     _hurd_pid, _hurd_pgrp,
 165                                                     &newctty))
 166                                 /* XXX it is our ctty but the call failed? */
 167                                 newctty = MACH_PORT_NULL;
 168                               __mach_port_deallocate
 169                                 (__mach_task_self (), (mach_port_t) id);
 170                             }
 171                           else
 172                             newctty = MACH_PORT_NULL;
 173                           0;
 174                         }));
 175
 176       /* Install the new ctty port.  */
 177       _hurd_port_set (&d->ctty, newctty);
 178     }
 179
 180   __mutex_unlock (&_hurd_dtable_lock);
 181   HURD_CRITICAL_END;
 182 }
 183
 184
 185 /* Called when we have received a message saying to use a new ctty ID port.  */
 186
 187 error_t
 188 _hurd_setcttyid (mach_port_t cttyid)
 189 {
 190   error_t err;
 191
 192   if (cttyid != MACH_PORT_NULL)
 193     {
 194       /* Give the new send right a user reference.
 195          This is a good way to check that it is valid.  */
 196       if (err = __mach_port_mod_refs (__mach_task_self (), cttyid,
 197                                       MACH_PORT_RIGHT_SEND, 1))
 198         return err;
 199     }
 200
 201   /* Install the port, consuming the reference we just created.  */
 202   _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], cttyid);
 203
 204   /* Reset all the ctty ports in all the descriptors.  */
 205   __USEPORT (CTTYID, (rectty_dtable (cttyid), 0));
 206
 207   return 0;
 208 }
 209
 210
 211 /* Make FD be the controlling terminal.
 212    This function is called for `ioctl (fd, TCIOSCTTY)'.  */
 213
 214 static int
 215 tiocsctty (int fd,
 216            int request)         /* Always TIOCSCTTY.  */
 217 {
 218   mach_port_t cttyid;
 219   error_t err;
 220
 221   /* Get FD's cttyid port, unless it is already ours.  */
 222   err = HURD_DPORT_USE (fd, ctty != MACH_PORT_NULL ? EADDRINUSE :
 223                         __term_getctty (port, &cttyid));
 224   if (err == EADDRINUSE)
 225     /* FD is already the ctty.  Nothing to do.  */
 226     return 0;
 227   else if (err)
 228     return __hurd_fail (err);
 229
 230   /* Change the terminal's pgrp to ours.  */
 231   err = HURD_DPORT_USE (fd, __tioctl_tiocspgrp (port, _hurd_pgrp));
 232   if (err)
 233     return __hurd_fail (err);
 234
 235   /* Make it our own.  */
 236   _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], cttyid);
 237
 238   /* Reset all the ctty ports in all the descriptors.  */
 239   __USEPORT (CTTYID, (rectty_dtable (cttyid), 0));
 240
 241   return 0;
 242 }
 243 _HURD_HANDLE_IOCTL (tiocsctty, TIOCSCTTY);
 244
 245 /* Dissociate from the controlling terminal.  */
 246
 247 static int
 248 tiocnotty (int fd,
 249            int request)         /* Always TIOCNOTTY.  */
 250 {
 251   mach_port_t fd_cttyid;
 252   error_t err;
 253
 254   if (err = HURD_DPORT_USE (fd, __term_getctty (port, &fd_cttyid)))
 255     return __hurd_fail (err);
 256
 257   if (__USEPORT (CTTYID, port != fd_cttyid))
 258     err = EINVAL;
 259
 260   __mach_port_deallocate (__mach_task_self (), fd_cttyid);
 261
 262   if (err)
 263     return __hurd_fail (err);
 264
 265   /* Clear our cttyid port cell.  */
 266   _hurd_port_set (&_hurd_ports[INIT_PORT_CTTYID], MACH_PORT_NULL);
 267
 268   /* Reset all the ctty ports in all the descriptors.  */
 269
 270   __USEPORT (CTTYID, (rectty_dtable (MACH_PORT_NULL), 0));
 271
 272   return 0;
 273 }
 274 _HURD_HANDLE_IOCTL (tiocnotty, TIOCNOTTY);