Formerly sysdeps/mach/hurd/__ioctl.c.~7~
[kopensolaris-gnu/glibc.git] / sysdeps / mach / hurd / ioctl.c
1 /* Copyright (C) 1992, 1993 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
24 /* Symbol set of ioctl handler lists.  If there are user-registered
25    handlers, one of these lists will contain them.  The other lists are
26    handlers built into the library.  */
27 const struct
28   {
29     size_t n;
30     struct ioctl_handler *v[0];
31   } _hurd_ioctl_handler_lists;
32
33
34 /* Perform the I/O control operation specified by REQUEST on FD.
35    The actual type and use of ARG and the return value depend on REQUEST.  */
36 int
37 DEFUN(__ioctl, (fd, request, arg),
38       int fd AND int request AND PTR arg)
39 {
40   /* Map individual type fields to Mach IPC types.  */
41   static const int mach_types[] =
42     { MACH_MSG_TYPE_CHAR, MACH_MSG_TYPE_INTEGER_16, MACH_MSG_TYPE_INTEGER_32,
43       -1 };
44
45   /* Message buffer.  */
46   char msg[sizeof (mach_msg_header_t) + /* Header.  */
47            sizeof (mach_msg_type_t) + 4 /* Return code.  */
48            3 * (sizeof (mach_msg_type_t) + (4 * 32))]; /* Argument data.  */
49   mach_msg_header_t *m = (mach_msg_header_t *) msg;
50   mach_msg_type_t *t = (mach_msg_type_t *) &m[1];
51   mach_msg_id_t msgid;
52
53   union __ioctl r;
54   error_t err;
55
56 #define io2mach_type(count, type) \
57   ((mach_msg_type_t)
58    { mach_types[type], (type << 1) * 8, count, 1, 0, 0 })
59
60   /* Pack an argument into the message buffer.  */
61   inline void in (unsigned int count, unsigned int type)
62     {
63       if (count > 0)
64         {
65           void *const p = &t[1];
66           const size_t len = count * (type << 1);
67           *t = io2mach_type (count, type);
68           memcpy (p, arg, len);
69           arg += len;
70           t = p + ((len + sizeof (*t) - 1) / sizeof (*t) * sizeof (*t));
71         }
72     }
73
74   /* Unpack the message buffer into the argument location.  */
75   inline int out (unsigned int count, unsigned int type,
76                   void *store, void **update)
77     {
78       if (count > 0)
79         {
80           const size_t len = count * (type << 1);
81           union { mach_msg_type_t t; int i; } ipctype;
82           ipctype.t = io2mach_type (count, type);
83           if (*(int *) t != ipctype.i)
84             return 1;
85           ++t;
86           memcpy (t, store, len);
87           if (update != NULL)
88             *update += len;
89           t = (void *) t + ((len + sizeof (*t) - 1) / sizeof (*t) * sizeof *t);
90         }
91       return 0;
92     }
93
94   {
95     /* Check for a registered handler for REQUEST.  */
96
97     size_t i;
98     const struct ioctl_handler *h;
99
100     for (i = 0; i < _hurd_ioctl_handler_lists.n; ++i)
101       for (h = _hurd_ioctl_handler_lists.v[i]; *h; h = h->next)
102         if (request >= h->first_request && request <= h->last_request)
103           /* This handler groks REQUEST.  Le puntamonos.  */
104           return (*h->handler) (fd, request, arg);
105   }
106   
107
108   /* Pack the argument data.  */
109   r.i = request;
110
111   msgid = 100000 + ((r.s.group << 2) * 1000) + r.s.command;
112
113   in (r.s.count0, r.s.type0);
114   in (r.s.count1, r.s.type1);
115   in (r.s.count2, r.s.type2);
116
117   err = _HURD_DPORT_USE
118     (fd,
119      ({
120        m->msgh_size = (char *) t - msg;
121        m->msgh_request_port = port;
122        m->msgh_reply_port = __mig_reply_port ();
123        m->msgh_seqno = 0;
124        m->msgh_id = msgid;
125        m->msgh_bits = ?;        /* XXX */
126        _HURD_EINTR_RPC (port, __mach_msg (m, MACH_SEND_MSG|MACH_RCV_MSG,
127                                           m->msgh_size, sizeof (msg),
128                                           m->msgh_reply_port,
129                                           MACH_MSG_TIMEOUT_NONE,
130                                           MACH_PORT_NULL));
131      }));
132
133   switch (err)
134     {
135     case MACH_MSG_SUCCESS:
136       break;
137     case MACH_SEND_INVALID_REPLY:
138     case MACH_RCV_INVALID_NAME:
139       __mig_dealloc_reply_port ();
140     default:
141       return __hurd_fail (err);
142     }
143
144   if (m->msgh_id != msgid + 100)
145     return __hurd_fail (m->msgh_id == MACH_NOTIFY_SEND_ONCE ?
146                         MIG_SERVER_DIED : MIG_REPLY_MISMATCH);
147
148   if ((m->msgh_bits & MACH_MSGH_BITS_COMPLEX) || /* XXX ? */
149       m->msgh_size != (char *) t - msg)
150     return __hurd_fail (MIG_TYPE_ERROR);
151
152   t = (mach_msg_type_t) &m[1];
153   if (out (1, _IOTS (sizeof (error_t)), &err, NULL) ||
154       out (r.s.count0, r.s.type0, arg, &arg) ||
155       out (r.s.count1, r.s.type2, arg, &arg) ||
156       out (r.s.count2, r.s.type2, arg, &arg))
157     return __hurd_fail (MIG_TYPE_ERROR);
158
159   if (err)
160     return __hurd_fail (err);
161   return 0;
162 }