.
[kopensolaris-gnu/glibc.git] / hurd / hurdioctl.c
1 /* ioctl commands which must be done in the C library.
2    Copyright (C) 1994,95,96,97,99,2001,02 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 Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the 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    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <hurd.h>
21 #include <hurd/fd.h>
22 #include <sys/ioctl.h>
23 #include <hurd/ioctl.h>
24 #include <string.h>
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 /* Install a new CTTYID port, atomically updating the dtable appropriately.
136    This consumes the send right passed in.  */
137
138 void
139 _hurd_locked_install_cttyid (mach_port_t cttyid)
140 {
141   mach_port_t old;
142   struct hurd_port *const port = &_hurd_ports[INIT_PORT_CTTYID];
143   struct hurd_userlink ulink;
144   int i;
145
146   /* Install the new cttyid port, and preserve it with a ulink.
147      We unroll the _hurd_port_set + _hurd_port_get here so that
148      there is no window where the cell is unlocked and CTTYID could
149      be changed by another thread.  (We also delay the deallocation
150      of the old port until the end, to minimize the duration of the
151      critical section.)
152
153      It is important that changing the cttyid port is only ever done by
154      holding the dtable lock continuously while updating the port cell and
155      re-ctty'ing the dtable; dtable.c assumes we do this.  Otherwise, the
156      pgrp-change notification code in dtable.c has to worry about racing
157      against us here in odd situations.  The one exception to this is
158      setsid, which holds the dtable lock while changing the pgrp and
159      clearing the cttyid port, and then unlocks the dtable lock to allow
160
161
162   */
163
164   __spin_lock (&port->lock);
165   old = _hurd_userlink_clear (&port->users) ? port->port : MACH_PORT_NULL;
166   port->port = cttyid;
167   cttyid = _hurd_port_locked_get (port, &ulink);
168
169   for (i = 0; i < _hurd_dtablesize; ++i)
170     {
171       struct hurd_fd *const d = _hurd_dtable[i];
172       mach_port_t newctty;
173
174       if (d == NULL)
175         /* Nothing to do for an unused descriptor cell.  */
176         continue;
177
178       if (cttyid == MACH_PORT_NULL)
179         /* We now have no controlling tty at all.  */
180         newctty = MACH_PORT_NULL;
181       else
182         HURD_PORT_USE (&d->port,
183                        ({ mach_port_t id;
184                           /* Get the io object's cttyid port.  */
185                           if (! __term_getctty (port, &id))
186                             {
187                               if (id == cttyid && /* Is it ours?  */
188                                   /* Get the ctty io port.  */
189                                   __term_open_ctty (port,
190                                                     _hurd_pid, _hurd_pgrp,
191                                                     &newctty))
192                                 /* XXX it is our ctty but the call failed? */
193                                 newctty = MACH_PORT_NULL;
194                               __mach_port_deallocate
195                                 (__mach_task_self (), (mach_port_t) id);
196                             }
197                           else
198                             newctty = MACH_PORT_NULL;
199                           0;
200                         }));
201
202       /* Install the new ctty port.  */
203       _hurd_port_set (&d->ctty, newctty);
204     }
205
206   __mutex_unlock (&_hurd_dtable_lock);
207
208   if (old != MACH_PORT_NULL)
209     __mach_port_deallocate (__mach_task_self (), old);
210   _hurd_port_free (port, &ulink, cttyid);
211 }
212
213 static void
214 install_ctty (mach_port_t cttyid)
215 {
216   HURD_CRITICAL_BEGIN;
217   __mutex_lock (&_hurd_dtable_lock);
218   _hurd_locked_install_cttyid (cttyid);
219   HURD_CRITICAL_END;
220 }
221
222
223 /* Called when we have received a message saying to use a new ctty ID port.  */
224
225 error_t
226 _hurd_setcttyid (mach_port_t cttyid)
227 {
228   error_t err;
229
230   if (cttyid != MACH_PORT_NULL)
231     {
232       /* Give the new send right a user reference.
233          This is a good way to check that it is valid.  */
234       if (err = __mach_port_mod_refs (__mach_task_self (), cttyid,
235                                       MACH_PORT_RIGHT_SEND, 1))
236         return err;
237     }
238
239   /* Install the port, consuming the reference we just created.  */
240   install_ctty (cttyid);
241
242   return 0;
243 }
244
245
246 /* Make FD be the controlling terminal.
247    This function is called for `ioctl (fd, TCIOSCTTY)'.  */
248
249 static int
250 tiocsctty (int fd,
251            int request)         /* Always TIOCSCTTY.  */
252 {
253   mach_port_t cttyid;
254   error_t err;
255
256   /* Get FD's cttyid port, unless it is already ours.  */
257   err = HURD_DPORT_USE (fd, ctty != MACH_PORT_NULL ? EADDRINUSE :
258                         __term_getctty (port, &cttyid));
259   if (err == EADDRINUSE)
260     /* FD is already the ctty.  Nothing to do.  */
261     return 0;
262   else if (err)
263     return __hurd_fail (err);
264
265   /* Change the terminal's pgrp to ours.  */
266   err = HURD_DPORT_USE (fd, __tioctl_tiocspgrp (port, _hurd_pgrp));
267   if (err)
268     return __hurd_fail (err);
269
270   /* Make it our own.  */
271   install_ctty (cttyid);
272
273   return 0;
274 }
275 _HURD_HANDLE_IOCTL (tiocsctty, TIOCSCTTY);
276
277 /* Dissociate from the controlling terminal.  */
278
279 static int
280 tiocnotty (int fd,
281            int request)         /* Always TIOCNOTTY.  */
282 {
283   mach_port_t fd_cttyid;
284   error_t err;
285
286   if (err = HURD_DPORT_USE (fd, __term_getctty (port, &fd_cttyid)))
287     return __hurd_fail (err);
288
289   if (__USEPORT (CTTYID, port != fd_cttyid))
290     err = EINVAL;
291
292   __mach_port_deallocate (__mach_task_self (), fd_cttyid);
293
294   if (err)
295     return __hurd_fail (err);
296
297   /* Clear our cttyid port.  */
298   install_ctty (MACH_PORT_NULL);
299
300   return 0;
301 }
302 _HURD_HANDLE_IOCTL (tiocnotty, TIOCNOTTY);
303 \f
304 #include <hurd/pfinet.h>
305 #include <net/if.h>
306 #include <netinet/in.h>
307
308 /* Fill in the buffer IFC->IFC_BUF of length IFC->IFC_LEN with a list
309    of ifr structures, one for each network interface.  */
310 static int
311 siocgifconf (int fd, int request, struct ifconf *ifc)
312 {
313   error_t err;
314   size_t data_len = ifc->ifc_len;
315   char *data = ifc->ifc_buf;
316
317   if (data_len <= 0)
318     return 0;
319
320   err = HURD_DPORT_USE (fd, __pfinet_siocgifconf (port, ifc->ifc_len,
321                                                   &data, &data_len));
322   if (data_len < ifc->ifc_len)
323     ifc->ifc_len = data_len;
324   if (data != ifc->ifc_buf)
325     {
326       memcpy (ifc->ifc_buf, data, ifc->ifc_len);
327       __vm_deallocate (__mach_task_self (), (vm_address_t) data, data_len);
328     }
329   return err ? __hurd_dfail (fd, err) : 0;
330 }
331 _HURD_HANDLE_IOCTL (siocgifconf, SIOCGIFCONF);