Include hurd/ioctl.h.
[kopensolaris-gnu/glibc.git] / 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);