Use _hurd_ctty_output.
[kopensolaris-gnu/glibc.git] / sysdeps / mach / hurd / ioctl.c
1 /* Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 #include <ansidecl.h>
20 #include <errno.h>
21 #include <sys/ioctl.h>
22 #include <hurd.h>
23 #include <hurd/fd.h>
24 #include <hurd/signal.h>
25 #include <stdarg.h>
26 #include <mach/notify.h>
27 #include <assert.h>
28 #include <string.h>
29 #include <hurd/ioctl.h>
30
31
32 #define typesize(type)  (1 << (type))
33
34
35 /* Perform the I/O control operation specified by REQUEST on FD.
36    The actual type and use of ARG and the return value depend on REQUEST.  */
37 int
38 DEFUN(__ioctl, (fd, request),
39       int fd AND unsigned long int request DOTS)
40 {
41   /* Map individual type fields to Mach IPC types.  */
42   static const int mach_types[] =
43     { MACH_MSG_TYPE_CHAR, MACH_MSG_TYPE_INTEGER_16, MACH_MSG_TYPE_INTEGER_32,
44       -1 };
45 #define io2mach_type(count, type) \
46   ((mach_msg_type_t) { mach_types[type], typesize (type) * 8, count, 1, 0, 0 })
47
48   /* Extract the type information encoded in the request.  */
49   unsigned int type = _IOC_TYPE (request);
50
51   /* Message buffer.  */
52   struct
53     {
54       mig_reply_header_t header;
55       char data[3 * sizeof (mach_msg_type_t) +
56                 _IOT_COUNT0 (type) * typesize (_IOT_TYPE0 (type)) +
57                 _IOT_COUNT1 (type) * typesize (_IOT_TYPE1 (type)) +
58                 _IOT_COUNT2 (type) * typesize (_IOT_TYPE2 (type))];
59     } msg;
60   mach_msg_header_t *const m = &msg.header.Head;
61   mach_msg_type_t *t = &msg.header.RetCodeType;
62   mach_msg_id_t msgid;
63   unsigned int reply_size;
64
65   void *arg;
66
67   error_t err;
68
69   /* Send the RPC already packed up in MSG to IOPORT
70      and decode the return value.  */
71   error_t send_rpc (io_t ioport)
72     {
73       error_t err;
74
75       m->msgh_size = (char *) t - (char *) &msg;
76       m->msgh_remote_port = ioport;
77       m->msgh_local_port = __mig_get_reply_port ();
78       m->msgh_seqno = 0;
79       m->msgh_id = msgid;
80       m->msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_COPY_SEND,
81                                      MACH_MSG_TYPE_MAKE_SEND_ONCE);
82       err = HURD_EINTR_RPC (ioport, __mach_msg (m, MACH_SEND_MSG|MACH_RCV_MSG,
83                                                 m->msgh_size, sizeof (msg),
84                                                 m->msgh_local_port,
85                                                 MACH_MSG_TIMEOUT_NONE,
86                                                 MACH_PORT_NULL));
87       switch (err)
88         {
89         case MACH_MSG_SUCCESS:
90           break;
91         case MACH_SEND_INVALID_REPLY:
92         case MACH_RCV_INVALID_NAME:
93           __mig_dealloc_reply_port (m->msgh_local_port);
94         default:
95           return err;
96         }
97
98       if ((m->msgh_bits & MACH_MSGH_BITS_COMPLEX))
99         {
100           /* Allow no ports or VM.  */
101           __mach_msg_destroy (m);
102           /* Want to return a different error below for a different msgid.  */
103           if (m->msgh_id == msgid + 100)
104             return MIG_TYPE_ERROR;
105         }
106
107       if (m->msgh_id != msgid + 100)
108         return (m->msgh_id == MACH_NOTIFY_SEND_ONCE ?
109                 MIG_SERVER_DIED : MIG_REPLY_MISMATCH);
110
111       if (m->msgh_size != reply_size &&
112           m->msgh_size != sizeof (mig_reply_header_t))
113         return MIG_TYPE_ERROR;
114
115       if (*(int *) &msg.header.RetCodeType !=
116           ((union { mach_msg_type_t t; int i; })
117            { t: io2mach_type (1, _IOTS (sizeof msg.header.RetCode)) }).i)
118         return MIG_TYPE_ERROR;
119       return msg.header.RetCode;
120     }
121
122   va_list ap;
123
124   va_start (ap, request);
125   arg = va_arg (ap, void *);
126   va_end (ap);
127
128   {
129     /* Check for a registered handler for REQUEST.  */
130     ioctl_handler_t handler = _hurd_lookup_ioctl_handler (request);
131     if (handler)
132       /* This handler groks REQUEST.  Se lo puntamonos.  */
133       return (*handler) (fd, request, arg);
134   }
135
136   /* Compute the Mach message ID for the RPC from the group and command
137      parts of the ioctl request.  */
138   msgid = 100000 + ((_IOC_GROUP (request) - 'f') * 4000); /* Base subsystem */
139   /* Because of MiG's poorly chosen algorithm of adding 100 to a request
140      msgid to produce the reply msgid, we cannot just add the command part
141      of the ioctl request to the subsystem base msgid.  For ioctl requests
142      past 99, we must skip blocks of 100 msgids to allow for the reply
143      msgids corresponding to the earlier requests.  */
144   if (_IOC_COMMAND (request) >= 100)
145     msgid += 100;
146   if (_IOC_COMMAND (request) >= 200)
147     msgid += 100;
148   msgid += _IOC_COMMAND (request);
149
150   if (_IOC_INOUT (request) & IOC_IN)
151     {
152       /* Pack an argument into the message buffer.  */
153       void in (unsigned int count, enum __ioctl_datum type)
154         {
155           if (count > 0)
156             {
157               void *p = &t[1];
158               const size_t len = count * typesize ((unsigned int) type);
159               *t = io2mach_type (count, type);
160               memcpy (p, arg, len);
161               arg += len;
162               p += len;
163               p = (void *) (((unsigned long int) p + sizeof (*t) - 1)
164                             & ~(sizeof (*t) - 1));
165               t = p;
166             }
167         }
168
169       /* Pack the argument data.  */
170       in (_IOT_COUNT0 (type), _IOT_TYPE0 (type));
171       in (_IOT_COUNT1 (type), _IOT_TYPE1 (type));
172       in (_IOT_COUNT2 (type), _IOT_TYPE2 (type));
173     }
174
175   /* Compute the expected size of the reply.  There is a standard header
176      consisting of the message header and the reply code.  Then, for out
177      and in/out ioctls, there come the data with their type headers.  */
178   reply_size = sizeof (mig_reply_header_t);
179
180   if (_IOC_INOUT (request) & IOC_OUT)
181     {
182       inline void figure_reply (unsigned int count, enum __ioctl_datum type)
183         {
184           if (count > 0)
185             {
186               /* Add the size of the type and data.  */
187               reply_size += sizeof (mach_msg_type_t) + typesize (type) * count;
188               /* Align it to word size.  */
189               reply_size += sizeof (mach_msg_type_t) - 1;
190               reply_size &= ~(sizeof (mach_msg_type_t) - 1);
191             }
192         }
193       figure_reply (_IOT_COUNT0 (type), _IOT_TYPE0 (type));
194       figure_reply (_IOT_COUNT1 (type), _IOT_TYPE1 (type));
195       figure_reply (_IOT_COUNT2 (type), _IOT_TYPE2 (type));
196     }
197
198   err = HURD_DPORT_USE (fd, _hurd_ctty_output (port, ctty, send_rpc));
199
200   t = (mach_msg_type_t *) msg.data;
201   switch (err)
202     {
203       /* Unpack the message buffer into the argument location.  */
204       int out (unsigned int count, unsigned int type,
205                void *store, void **update)
206         {
207           if (count > 0)
208             {
209               const size_t len = count * typesize (type);
210               union { mach_msg_type_t t; int i; } ipctype;
211               ipctype.t = io2mach_type (count, type);
212               if (*(int *) t != ipctype.i)
213                 return 1;
214               ++t;
215               memcpy (store, t, len);
216               if (update != NULL)
217                 *update += len;
218               t = (void *) (((unsigned long int) t + len + sizeof (*t) - 1)
219                             & ~(sizeof (*t) - 1));
220             }
221           return 0;
222         }
223
224     case 0:
225       if (m->msgh_size != reply_size ||
226           ((_IOC_INOUT (request) & IOC_OUT) &&
227            (out (_IOT_COUNT0 (type), _IOT_TYPE0 (type), arg, &arg) ||
228             out (_IOT_COUNT1 (type), _IOT_TYPE1 (type), arg, &arg) ||
229             out (_IOT_COUNT2 (type), _IOT_TYPE2 (type), arg, &arg))))
230         return __hurd_fail (MIG_TYPE_ERROR);
231       return 0;
232
233     case MIG_BAD_ID:
234     case EOPNOTSUPP:
235       /* The server didn't understand the RPC.  */
236       err = ENOTTY;
237     default:
238       return __hurd_fail (err);
239     }
240 }
241
242 weak_alias (__ioctl, ioctl)