sys/alpha/osf1/osf1_ioctl.c

   1 /*      $NetBSD: osf1_ioctl.c,v 1.5 1996/10/13 00:46:53 christos Exp $  */
   2
   3 /*
   4  * Copyright (c) 1994, 1995 Carnegie-Mellon University.
   5  * All rights reserved.
   6  *
   7  * Author: Chris G. Demetriou
   8  *
   9  * Permission to use, copy, modify and distribute this software and
  10  * its documentation is hereby granted, provided that both the copyright
  11  * notice and this permission notice appear in all copies of the
  12  * software, derivative works or modified versions, and any portions
  13  * thereof, and that both notices appear in supporting documentation.
  14  *
  15  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  16  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  17  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  18  *
  19  * Carnegie Mellon requests users of this software to return to
  20  *
  21  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  22  *  School of Computer Science
  23  *  Carnegie Mellon University
  24  *  Pittsburgh PA 15213-3890
  25  *
  26  * any improvements or extensions that they make and grant Carnegie the
  27  * rights to redistribute these changes.
  28  */
  29
  30 /*
  31  * Additional Copyright (c) 1999 by Andrew Gallatin
  32  * $FreeBSD$
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/fcntl.h>
  38 #include <sys/filio.h>
  39 #include <sys/ioctl_compat.h>
  40 #include <sys/termios.h>
  41 #include <sys/filedesc.h>
  42 #include <sys/file.h>
  43 #include <sys/proc.h>
  44 #include <sys/mount.h>
  45 #include <sys/sysproto.h>
  46 #include <alpha/osf1/osf1_signal.h>
  47 #include <alpha/osf1/osf1_proto.h>
  48 #include <alpha/osf1/osf1.h>
  49 #include <sys/socket.h>
  50 #include <net/if.h>
  51 #include <net/if_dl.h>
  52 #include <net/if_types.h>
  53 #include <sys/sockio.h>
  54
  55 #include "opt_compat.h"
  56
  57 /*#define       IOCTL_DEBUG*/
  58
  59 int osf1_ioctl_i        __P((struct proc *p, struct ioctl_args *nuap,
  60                             int cmd, int dir, int len));
  61 int osf1_ioctl_t        __P((struct proc *p, struct ioctl_args *nuap,
  62                             int cmd, int dir, int len));
  63 int osf1_ioctl_f        __P((struct proc *p, struct ioctl_args *nuap,
  64                             int cmd, int dir, int len));
  65
  66 int
  67 osf1_ioctl(p, uap)
  68         struct proc *p;
  69         struct osf1_ioctl_args *uap;
  70 {
  71         char *dirstr;
  72         unsigned int cmd, dir, group, len, op;
  73         struct ioctl_args /* {
  74                 syscallarg(int) fd;
  75                 syscallarg(u_long) com;
  76                 syscallarg(caddr_t) data;
  77         } */ a;
  78
  79         op = uap->com;
  80         dir = op & OSF1_IOC_DIRMASK;
  81         group = OSF1_IOCGROUP(op);
  82         cmd = OSF1_IOCCMD(op);
  83         len = OSF1_IOCPARM_LEN(op);
  84
  85         switch (dir) {
  86         case OSF1_IOC_VOID:
  87                 dir = IOC_VOID;
  88                 dirstr = "none";
  89                 break;
  90
  91         case OSF1_IOC_OUT:
  92                 dir = IOC_OUT;
  93                 dirstr = "out";
  94                 break;
  95
  96         case OSF1_IOC_IN:
  97                 dir = IOC_IN;
  98                 dirstr = "in";
  99                 break;
 100
 101         case OSF1_IOC_INOUT:
 102                 dir = IOC_INOUT;
 103                 dirstr = "in-out";
 104                 break;
 105
 106         default:
 107                 return (EINVAL);
 108                 break;
 109         }
 110 #ifdef IOCTL_DEBUG
 111                 uprintf(
 112                     "OSF/1 IOCTL: group = %c, cmd = %d, len = %d, dir = %s\n",
 113                     group, cmd, len, dirstr);
 114 #endif
 115
 116         a.fd = uap->fd;
 117         a.com = (unsigned long)uap->com;
 118         bzero(&a.com, sizeof(long));
 119         a.com = _IOC(dir, group, cmd, len);
 120         a.data = uap->data;
 121         switch (group) {
 122         case 'i':
 123                 return osf1_ioctl_i(p, &a, cmd, dir, len);
 124         case 't':
 125                 return osf1_ioctl_t(p, &a, cmd, dir, len);
 126         case 'f':
 127                 return osf1_ioctl_f(p, &a, cmd, dir, len);
 128         default:
 129                 printf(
 130                     "unimplented OSF/1 IOCTL: group = %c, cmd = %d, len = %d, dir = %s\n",
 131                     group, cmd, len, dirstr);
 132                 return (ENOTTY);
 133         }
 134 }
 135
 136 /*
 137  * Structure used to query de and qe for physical addresses.
 138  */
 139 struct osf1_ifdevea {
 140         char   ifr_name[IFNAMSIZ];      /* if name, e.g. "en0" */
 141         u_char default_pa[6];           /* default hardware address */
 142         u_char current_pa[6];           /* current physical address */
 143 };
 144
 145
 146 int
 147 osf1_ioctl_i(p, uap, cmd, dir, len)
 148         struct proc *p;
 149         struct ioctl_args /* {
 150                 syscallarg(int) fd;
 151                 syscallarg(u_long) com;
 152                 syscallarg(caddr_t) data;
 153         } */ *uap;
 154         int cmd;
 155         int dir;
 156         int len;
 157 {
 158
 159         switch (cmd) {
 160         case 20:                        /* OSF/1 OSIOCGIFCONF */
 161         case 36:                        /* OSF/1  SIOCGIFCONF */
 162         case 12:                        /* OSF/1 SIOCSIFADDR */
 163         case 14:                        /* OSF/1 SIOCSIFDSTADDR */
 164         case 16:                        /* OSF/1 SIOCSIFFLAGS (XXX) */
 165         case 17:                        /* OSF/1 SIOCGIFFLAGS (XXX) */
 166         case 19:                        /* OSF/1 SIOCSIFBRDADDR */
 167         case 22:                        /* OSF/1 SIOCSIFNETMASK */
 168         case 23:                        /* OSF/1 SIOCGIFMETRIC */
 169         case 24:                        /* OSF/1 SIOCSIFMETRIC */
 170         case 25:                        /* OSF/1 SIOCDIFADDR */
 171         case 33:                        /* OSF/1 SIOCGIFADDR */
 172         case 34:                        /* OSF/1 SIOCGIFDSTADDR */
 173         case 35:                        /* OSF/1 SIOCGIFBRDADDR */
 174         case 37:                        /* OSF/1 SIOCGIFNETMASK */
 175                 /* same as in FreeBSD */
 176                 return ioctl(p, uap);
 177                 break;
 178
 179         case 62:                        /* OSF/1 SIOCRPHYSADDR */
 180
 181         {
 182                 int                     ifn, retval;
 183                 struct ifnet            *ifp;
 184                 struct ifaddr           *ifa;
 185                 struct sockaddr_dl      *sdl;
 186                 struct osf1_ifdevea     *ifd = (struct osf1_ifdevea *)uap->data;
 187
 188                 /*
 189                  * Note that we don't actually respect the name in the ifreq
 190                  * structure, as DU interface names are all different.
 191                  */
 192                 for (ifn = 0; ifn < if_index; ifn++) {
 193                         ifp = ifnet_addrs[ifn]->ifa_ifp;    /* pointer to interface */
 194                         /* Only look at ether interfaces, exclude alteon nics
 195                          * because osf/1 doesn't know about most of them.
 196                          */
 197                         if (ifp->if_type == IFT_ETHER
 198                             && strcmp(ifp->if_name, "ti")) {    /* looks good */
 199                                 /* walk the address list */
 200                                 for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa;
 201                                     ifa = TAILQ_NEXT(ifa, ifa_link)) {
 202                                         if ((sdl = (struct sockaddr_dl *)ifa->ifa_addr) /* we have an address structure */
 203                                             && (sdl->sdl_family == AF_LINK)             /* it's a link address */
 204                                             && (sdl->sdl_type == IFT_ETHER)) {          /* for an ethernet link */
 205                                                 retval = copyout(LLADDR(sdl),
 206                                                     (caddr_t)&ifd->current_pa,
 207                                                     6);
 208                                                 if (!retval) {
 209                                                         return(copyout(
 210                                                             LLADDR(sdl),
 211                                                             (caddr_t)&ifd->default_pa,
 212                                                             6));
 213                                                 }
 214                                         }
 215                                 }
 216                         }
 217                 }
 218                 return(ENOENT);         /* ??? */
 219         }
 220
 221
 222         default:
 223                 printf("osf1_ioctl_i: cmd = %d\n", cmd);
 224                 return (ENOTTY);
 225         }
 226
 227
 228 }
 229 #ifndef _SGTTYB_
 230 #define _SGTTYB_
 231 struct sgttyb {
 232         char    sg_ispeed;              /* input speed */
 233         char    sg_ospeed;              /* output speed */
 234         char    sg_erase;               /* erase character */
 235         char    sg_kill;                /* kill character */
 236         short   sg_flags;               /* mode flags */
 237 };
 238 #endif
 239
 240 int
 241 osf1_ioctl_t(p, uap, cmd, dir, len)
 242         struct proc *p;
 243         struct ioctl_args /* {
 244                 syscallarg(int) fd;
 245                 syscallarg(u_long) com;
 246                 syscallarg(caddr_t) data;
 247         } */ *uap;
 248         int cmd;
 249         int dir;
 250         int len;
 251 {
 252         int retval;
 253
 254         switch (cmd) {
 255 #ifdef COMPAT_43
 256         case 0:                         /* OSF/1 COMPAT_43 TIOCGETD  */
 257         case 1:                         /* OSF/1 COMPAT_43 TIOCSETD  */
 258         case 8:                         /* OSF/1 COMPAT_43 TIOCGETP  */
 259         case 9:                         /* OSF/1 COMPAT_43 TIOCSETP  */
 260         case 10:                        /* OSF/1 COMPAT_43 TIOCSETN */
 261         case 17:                        /* OSF/1 TIOCSETC (XXX) */
 262         case 18:                        /* OSF/1 TIOCGETC (XXX) */
 263         case 116:                       /* OSF/1 TIOCSLTC */
 264         case 117:                       /* OSF/1 TIOCGLTC */
 265         case 124:                       /* OSF/1 TIOCLGET */
 266         case 125:                       /* OSF/1 TIOCLSET */
 267         case 126:                       /* OSF/1 TIOCLBIC */
 268         case 127:                       /* OSF/1 TIOCLBIS */
 269 #endif
 270         case 19:                        /* OSF/1 TIOCGETA (XXX) */
 271         case 20:                        /* OSF/1 TIOCSETA (XXX) */
 272         case 21:                        /* OSF/1 TIOCSETAW (XXX) */
 273         case 22:                        /* OSF/1 TIOCSETAF (XXX) */
 274         case 26:                        /* OSF/1 TIOCGETD (XXX) */
 275         case 27:                        /* OSF/1 TIOCSETD (XXX) */
 276         case 97:                        /* OSF/1 TIOCSCTTY */
 277         case 103:                       /* OSF/1 TIOCSWINSZ */
 278         case 104:                       /* OSF/1 TIOCGWINSZ */
 279         case 110:                       /* OSF/1 TIOCSTART */
 280         case 111:                       /* OSF/1 TIOCSTOP */
 281         case 118:                       /* OSF/1 TIOCGPGRP */
 282         case 119:                       /* OSF/1 TIOCGPGRP */
 283                 /* same as in NetBSD */
 284                 break;
 285
 286
 287         default:
 288                 printf("osf1_ioctl_t: cmd = %d\n", cmd);
 289                 return (ENOTTY);
 290         }
 291
 292         retval = ioctl(p, uap);
 293 #if 0
 294         if (retval)
 295                 printf("osf1_ioctl_t: cmd = %d, com = 0x%lx, retval = %d\n",
 296                        cmd, uap->com,retval);
 297 #endif
 298         return retval;
 299 }
 300
 301 int
 302 osf1_ioctl_f(p, uap, cmd, dir, len)
 303         struct proc *p;
 304         struct ioctl_args /* {
 305                 syscallarg(int) fd;
 306                 syscallarg(int) com;
 307                 syscallarg(caddr_t) data;
 308         } */ *uap;
 309         int cmd;
 310         int dir;
 311         int len;
 312 {
 313
 314         switch (cmd) {
 315         case 1:                         /* OSF/1 FIOCLEX (XXX) */
 316         case 2:                         /* OSF/1 FIONCLEX (XXX) */
 317         case 127:                       /* OSF/1 FIONREAD (XXX) */
 318         case 126:                       /* OSF/1 FIONREAD (XXX) */
 319         case 125:                       /* OSF/1 FIOASYNC (XXX) */
 320         case 124:                       /* OSF/1 FIOSETOWN (XXX) */
 321         case 123:                       /* OSF/1 FIOGETOWN (XXX) */
 322                 /* same as in FreeBSD */
 323                 break;
 324
 325         default:
 326                 printf("osf1_ioctl_f: cmd = %d\n", cmd);
 327                 return (ENOTTY);
 328         }
 329
 330         return ioctl(p, uap);
 331 }