Formerly sysdeps/mach/hurd/__ioctl.c.~23~
[kopensolaris-gnu/glibc.git] / sysdeps / mach / hurd / ioctl.c
1 /* Copyright (C) 1992, 1993, 1994 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 <stdarg.h>
25 #include <mach/notify.h>
26 #include <assert.h>
27
28 /* Symbol set of ioctl handler lists.  If there are user-registered
29    handlers, one of these lists will contain them.  The other lists are
30    handlers built into the library.  The definition of the set comes from
31    hurdioctl.c.  */
32 extern const struct
33   {
34     size_t n;
35     struct ioctl_handler *v[0];
36   } _hurd_ioctl_handler_lists;
37
38
39 /* Perform the I/O control operation specified by REQUEST on FD.
40    The actual type and use of ARG and the return value depend on REQUEST.  */
41 int
42 DEFUN(__ioctl, (fd, request),
43       int fd AND unsigned long int request DOTS)
44 {
45   /* Map individual type fields to Mach IPC types.  */
46   static const int mach_types[] =
47     { MACH_MSG_TYPE_CHAR, MACH_MSG_TYPE_INTEGER_16, MACH_MSG_TYPE_INTEGER_32,
48       -1 };
49
50   /* Extract the type information encoded in the request.  */
51   unsigned int type = _IOC_TYPE (request);
52
53   /* Message buffer.  */
54   struct
55     {
56       mig_reply_header_t header;
57       char data[_IOT_COUNT0 (type) * (_IOT_TYPE0 (request) << 1) +
58                 _IOT_COUNT1 (type) * (_IOT_TYPE1 (request) << 1) +
59                 _IOT_COUNT2 (type) * (_IOT_TYPE2 (request) << 1)];
60     } msg;
61   mach_msg_header_t *const m = &msg.header.Head;
62   mach_msg_type_t *t = &msg.header.RetCodeType;
63   mach_msg_id_t msgid;
64   unsigned int reply_size;
65
66   void *arg;
67
68   error_t err;
69
70 #define io2mach_type(count, type) \
71   ((mach_msg_type_t) { mach_types[type], (type << 1) * 8, count, 1, 0, 0 })
72
73   va_list ap;
74
75   va_start (ap, request);
76   arg = va_arg (ap, void *);
77   va_end (ap);
78
79   {
80     /* Check for a registered handler for REQUEST.  */
81
82     size_t i;
83     const struct ioctl_handler *h;
84
85     for (i = 0; i < _hurd_ioctl_handler_lists.n; ++i)
86       for (h = _hurd_ioctl_handler_lists.v[i]; h != NULL; h = h->next)
87         if (request >= h->first_request && request <= h->last_request)
88           /* This handler groks REQUEST.  Se lo puntamonos.  */
89           return (*h->handler) (fd, request, arg);
90   }
91
92   /* Compute the Mach message ID for the RPC from the group and command
93      parts of the ioctl request.  */
94   msgid = (100000 +
95            ((_IOC_GROUP (request) - 'f') * 4000) + _IOC_COMMAND (request));
96
97   if (_IOC_INOUT (request) & IOC_IN)
98     {
99       /* Pack an argument into the message buffer.  */
100       inline void in (unsigned int count, enum __ioctl_datum type)
101         {
102           if (count > 0)
103             {
104               void *p = &t[1];
105               const size_t len = count * ((unsigned int) type << 1);
106               *t = io2mach_type (count, type);
107               memcpy (p, arg, len);
108               arg += len;
109               p += len;
110               p = (void *) (((unsigned long int) p + sizeof (*t) - 1)
111                             & ~(sizeof (*t) - 1));
112               t = p;
113             }
114         }
115
116       /* Pack the argument data.  */
117       in (_IOT_COUNT0 (type), _IOT_TYPE0 (type));
118       in (_IOT_COUNT1 (type), _IOT_TYPE1 (type));
119       in (_IOT_COUNT2 (type), _IOT_TYPE2 (type));
120     }
121
122   /* Compute the expected size of the reply.  There is a standard header
123      consisting of the message header and the reply code.  Then, for out
124      and in/out ioctls, there come the data with their type headers.  */
125   reply_size = sizeof (mig_reply_header_t);
126
127   if (_IOC_INOUT (request) & IOC_OUT)
128     {
129       inline void figure_reply (unsigned int count, enum __ioctl_datum type)
130         {
131           if (count > 0)
132             {
133               /* Add the size of the type and data.  */
134               reply_size += sizeof (mach_msg_type_t) + (type << 1) * count;
135               /* Align it to word size.  */
136               reply_size += sizeof (mach_msg_type_t) - 1;
137               reply_size &= ~(sizeof (mach_msg_type_t) - 1);
138             }
139         }
140       figure_reply (_IOT_COUNT0 (request), _IOT_TYPE0 (request));
141       figure_reply (_IOT_COUNT1 (request), _IOT_TYPE1 (request));
142       figure_reply (_IOT_COUNT2 (request), _IOT_TYPE2 (request));
143     }
144
145   /* Send the RPC.  */
146
147   err = HURD_DPORT_USE
148     (fd,
149      ({
150        m->msgh_size = (char *) t - (char *) &msg;
151        m->msgh_remote_port = port;
152        m->msgh_local_port = __mig_get_reply_port ();
153        m->msgh_seqno = 0;
154        m->msgh_id = msgid;
155        m->msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_COPY_SEND,
156                                       MACH_MSG_TYPE_MAKE_SEND_ONCE);
157 #ifdef notyet
158        HURD_EINTR_RPC (port, __mach_msg (m, MACH_SEND_MSG|MACH_RCV_MSG,
159                                          m->msgh_size, sizeof (msg),
160                                          m->msgh_local_port,
161                                          MACH_MSG_TIMEOUT_NONE,
162                                          MACH_PORT_NULL));
163 #else
164        __mach_msg (m, MACH_SEND_MSG|MACH_RCV_MSG, m->msgh_size, sizeof (msg),
165                    m->msgh_local_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
166 #endif       
167      }));
168
169   switch (err)
170     {
171     case MACH_MSG_SUCCESS:
172       break;
173     case MACH_SEND_INVALID_REPLY:
174     case MACH_RCV_INVALID_NAME:
175       __mig_dealloc_reply_port ();
176     default:
177       return __hurd_fail (err);
178     }
179
180   if ((m->msgh_bits & MACH_MSGH_BITS_COMPLEX))
181     {
182       /* Allow no ports or VM.  */
183       __mach_msg_destroy (m);
184       /* Want to return a different error below for a different msgid.  */
185       if (m->msgh_id == msgid + 100)
186         return __hurd_fail (MIG_TYPE_ERROR);
187     }
188
189   if (m->msgh_id != msgid + 100)
190     return __hurd_fail (m->msgh_id == MACH_NOTIFY_SEND_ONCE ?
191                         MIG_SERVER_DIED : MIG_REPLY_MISMATCH);
192
193   if (m->msgh_size != reply_size &&
194       m->msgh_size != sizeof (mig_reply_header_t))
195     return __hurd_fail (MIG_TYPE_ERROR);
196
197   if (*(int *) &msg.header.RetCodeType !=
198       ((union { mach_msg_type_t t; int i; })
199        { t: io2mach_type (1, _IOTS (sizeof msg.header.RetCode)) }).i)
200     return __hurd_fail (MIG_TYPE_ERROR);
201   err = msg.header.RetCode;
202
203   t = (mach_msg_type_t *) msg.data;
204   switch (err)
205     {
206       /* Unpack the message buffer into the argument location.  */
207       inline int out (unsigned int count, unsigned int type,
208                       void *store, void **update)
209         {
210           if (count > 0)
211             {
212               const size_t len = count * (type << 1);
213               union { mach_msg_type_t t; int i; } ipctype;
214               ipctype.t = io2mach_type (count, type);
215               if (*(int *) t != ipctype.i)
216                 return 1;
217               ++t;
218               memcpy (store, t, len);
219               if (update != NULL)
220                 *update += len;
221               t = (void *) (((unsigned long int) t + len + sizeof (*t) - 1)
222                             & ~(sizeof (*t) - 1));
223             }
224           return 0;
225         }
226
227     case 0:
228       if (m->msgh_size != reply_size ||
229           out (_IOT_COUNT0 (type), _IOT_TYPE0 (type), arg, &arg) ||
230           out (_IOT_COUNT1 (type), _IOT_TYPE1 (type), arg, &arg) ||
231           out (_IOT_COUNT2 (type), _IOT_TYPE2 (type), arg, &arg))
232         return __hurd_fail (MIG_TYPE_ERROR);
233       return 0;
234
235     case MIG_BAD_ID:
236     case EOPNOTSUPP:
237       /* The server didn't understand the RPC.  */
238       err = ENOTTY;
239     default:
240       return __hurd_fail (err);
241     }
242 }