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