Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/i386/ibcs2/ibcs2_ioctl.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: ibcs2_ioctl.c,v 1.6 1995/03/14 15:12:28 scottb Exp $ */ 2 3 /* 4 * Copyright (c) 1994, 1995 Scott Bartram 5 * All rights reserved. 6 * 7 * based on compat/sunos/sun_ioctl.c 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/namei.h> 32 #include <sys/dir.h> 33 #include <sys/proc.h> 34 #include <sys/file.h> 35 #include <sys/stat.h> 36 #include <sys/filedesc.h> 37 #include <sys/ioctl.h> 38 #include <sys/ioctl_compat.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/mbuf.h> 42 #include <sys/mman.h> 43 #include <sys/mount.h> 44 #include <sys/reboot.h> 45 #include <sys/resource.h> 46 #include <sys/resourcevar.h> 47 #include <sys/signal.h> 48 #include <sys/signalvar.h> 49 #include <sys/socket.h> 50 #include <sys/termios.h> 51 #include <sys/time.h> 52 #include <sys/times.h> 53 #include <sys/tty.h> 54 #include <sys/vnode.h> 55 #include <sys/uio.h> 56 #include <sys/wait.h> 57 #include <sys/utsname.h> 58 #include <sys/unistd.h> 59 #include <machine/console.h> 60 61 #include <net/if.h> 62 #include <sys/sysproto.h> 63 64 #include <i386/ibcs2/ibcs2_types.h> 65 #include <i386/ibcs2/ibcs2_signal.h> 66 #include <i386/ibcs2/ibcs2_socksys.h> 67 #include <i386/ibcs2/ibcs2_stropts.h> 68 #include <i386/ibcs2/ibcs2_proto.h> 69 #include <i386/ibcs2/ibcs2_termios.h> 70 #include <i386/ibcs2/ibcs2_util.h> 71 #include <i386/ibcs2/ibcs2_ioctl.h> 72 73 static void stios2btios __P((struct ibcs2_termios *, struct termios *)); 74 static void btios2stios __P((struct termios *, struct ibcs2_termios *)); 75 static void stios2stio __P((struct ibcs2_termios *, struct ibcs2_termio *)); 76 static void stio2stios __P((struct ibcs2_termio *, struct ibcs2_termios *)); 77 78 79 int 80 ibcs2_gtty(struct proc *p, struct ibcs2_gtty_args *args, int *retval) 81 { 82 struct ioctl_args ioctl_arg; 83 84 ioctl_arg.fd = args->fd; 85 ioctl_arg.com = TIOCGETC; 86 ioctl_arg.data = (caddr_t)args->buf; 87 88 return ioctl(p, &ioctl_arg, retval); 89 } 90 91 int 92 ibcs2_stty(struct proc *p, struct ibcs2_stty_args *args, int *retval) 93 { 94 struct ioctl_args ioctl_arg; 95 96 ioctl_arg.fd = args->fd; 97 ioctl_arg.com = TIOCSETC; 98 ioctl_arg.data = (caddr_t)args->buf; 99 100 return ioctl(p, &ioctl_arg, retval); 101 } 102 103 104 /* 105 * iBCS2 ioctl calls. 106 */ 107 108 static struct speedtab sptab[] = { 109 { 0, 0 }, 110 { 50, 1 }, 111 { 75, 2 }, 112 { 110, 3 }, 113 { 134, 4 }, 114 { 135, 4 }, 115 { 150, 5 }, 116 { 200, 6 }, 117 { 300, 7 }, 118 { 600, 8 }, 119 { 1200, 9 }, 120 { 1800, 10 }, 121 { 2400, 11 }, 122 { 4800, 12 }, 123 { 9600, 13 }, 124 { 19200, 14 }, 125 { 38400, 15 }, 126 { -1, -1 } 127 }; 128 129 static u_long s2btab[] = { 130 0, 131 50, 132 75, 133 110, 134 134, 135 150, 136 200, 137 300, 138 600, 139 1200, 140 1800, 141 2400, 142 4800, 143 9600, 144 19200, 145 38400, 146 }; 147 148 static void 149 stios2btios(st, bt) 150 struct ibcs2_termios *st; 151 struct termios *bt; 152 { 153 register u_long l, r; 154 155 l = st->c_iflag; r = 0; 156 if (l & IBCS2_IGNBRK) r |= IGNBRK; 157 if (l & IBCS2_BRKINT) r |= BRKINT; 158 if (l & IBCS2_IGNPAR) r |= IGNPAR; 159 if (l & IBCS2_PARMRK) r |= PARMRK; 160 if (l & IBCS2_INPCK) r |= INPCK; 161 if (l & IBCS2_ISTRIP) r |= ISTRIP; 162 if (l & IBCS2_INLCR) r |= INLCR; 163 if (l & IBCS2_IGNCR) r |= IGNCR; 164 if (l & IBCS2_ICRNL) r |= ICRNL; 165 if (l & IBCS2_IXON) r |= IXON; 166 if (l & IBCS2_IXANY) r |= IXANY; 167 if (l & IBCS2_IXOFF) r |= IXOFF; 168 if (l & IBCS2_IMAXBEL) r |= IMAXBEL; 169 bt->c_iflag = r; 170 171 l = st->c_oflag; r = 0; 172 if (l & IBCS2_OPOST) r |= OPOST; 173 if (l & IBCS2_ONLCR) r |= ONLCR; 174 if (l & IBCS2_TAB3) r |= OXTABS; 175 bt->c_oflag = r; 176 177 l = st->c_cflag; r = 0; 178 switch (l & IBCS2_CSIZE) { 179 case IBCS2_CS5: r |= CS5; break; 180 case IBCS2_CS6: r |= CS6; break; 181 case IBCS2_CS7: r |= CS7; break; 182 case IBCS2_CS8: r |= CS8; break; 183 } 184 if (l & IBCS2_CSTOPB) r |= CSTOPB; 185 if (l & IBCS2_CREAD) r |= CREAD; 186 if (l & IBCS2_PARENB) r |= PARENB; 187 if (l & IBCS2_PARODD) r |= PARODD; 188 if (l & IBCS2_HUPCL) r |= HUPCL; 189 if (l & IBCS2_CLOCAL) r |= CLOCAL; 190 bt->c_cflag = r; 191 192 l = st->c_lflag; r = 0; 193 if (l & IBCS2_ISIG) r |= ISIG; 194 if (l & IBCS2_ICANON) r |= ICANON; 195 if (l & IBCS2_ECHO) r |= ECHO; 196 if (l & IBCS2_ECHOE) r |= ECHOE; 197 if (l & IBCS2_ECHOK) r |= ECHOK; 198 if (l & IBCS2_ECHONL) r |= ECHONL; 199 if (l & IBCS2_NOFLSH) r |= NOFLSH; 200 if (l & IBCS2_TOSTOP) r |= TOSTOP; 201 bt->c_lflag = r; 202 203 bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f]; 204 205 bt->c_cc[VINTR] = 206 st->c_cc[IBCS2_VINTR] ? st->c_cc[IBCS2_VINTR] : _POSIX_VDISABLE; 207 bt->c_cc[VQUIT] = 208 st->c_cc[IBCS2_VQUIT] ? st->c_cc[IBCS2_VQUIT] : _POSIX_VDISABLE; 209 bt->c_cc[VERASE] = 210 st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE; 211 bt->c_cc[VKILL] = 212 st->c_cc[IBCS2_VKILL] ? st->c_cc[IBCS2_VKILL] : _POSIX_VDISABLE; 213 if (bt->c_lflag & ICANON) { 214 bt->c_cc[VEOF] = 215 st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE; 216 bt->c_cc[VEOL] = 217 st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE; 218 } else { 219 bt->c_cc[VMIN] = st->c_cc[IBCS2_VMIN]; 220 bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME]; 221 } 222 bt->c_cc[VEOL2] = 223 st->c_cc[IBCS2_VEOL2] ? st->c_cc[IBCS2_VEOL2] : _POSIX_VDISABLE; 224 #if 0 225 bt->c_cc[VSWTCH] = 226 st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE; 227 #endif 228 bt->c_cc[VSTART] = 229 st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE; 230 bt->c_cc[VSTOP] = 231 st->c_cc[IBCS2_VSTOP] ? st->c_cc[IBCS2_VSTOP] : _POSIX_VDISABLE; 232 bt->c_cc[VSUSP] = 233 st->c_cc[IBCS2_VSUSP] ? st->c_cc[IBCS2_VSUSP] : _POSIX_VDISABLE; 234 bt->c_cc[VDSUSP] = _POSIX_VDISABLE; 235 bt->c_cc[VREPRINT] = _POSIX_VDISABLE; 236 bt->c_cc[VDISCARD] = _POSIX_VDISABLE; 237 bt->c_cc[VWERASE] = _POSIX_VDISABLE; 238 bt->c_cc[VLNEXT] = _POSIX_VDISABLE; 239 bt->c_cc[VSTATUS] = _POSIX_VDISABLE; 240 } 241 242 static void 243 btios2stios(bt, st) 244 struct termios *bt; 245 struct ibcs2_termios *st; 246 { 247 register u_long l, r; 248 249 l = bt->c_iflag; r = 0; 250 if (l & IGNBRK) r |= IBCS2_IGNBRK; 251 if (l & BRKINT) r |= IBCS2_BRKINT; 252 if (l & IGNPAR) r |= IBCS2_IGNPAR; 253 if (l & PARMRK) r |= IBCS2_PARMRK; 254 if (l & INPCK) r |= IBCS2_INPCK; 255 if (l & ISTRIP) r |= IBCS2_ISTRIP; 256 if (l & INLCR) r |= IBCS2_INLCR; 257 if (l & IGNCR) r |= IBCS2_IGNCR; 258 if (l & ICRNL) r |= IBCS2_ICRNL; 259 if (l & IXON) r |= IBCS2_IXON; 260 if (l & IXANY) r |= IBCS2_IXANY; 261 if (l & IXOFF) r |= IBCS2_IXOFF; 262 if (l & IMAXBEL) r |= IBCS2_IMAXBEL; 263 st->c_iflag = r; 264 265 l = bt->c_oflag; r = 0; 266 if (l & OPOST) r |= IBCS2_OPOST; 267 if (l & ONLCR) r |= IBCS2_ONLCR; 268 if (l & OXTABS) r |= IBCS2_TAB3; 269 st->c_oflag = r; 270 271 l = bt->c_cflag; r = 0; 272 switch (l & CSIZE) { 273 case CS5: r |= IBCS2_CS5; break; 274 case CS6: r |= IBCS2_CS6; break; 275 case CS7: r |= IBCS2_CS7; break; 276 case CS8: r |= IBCS2_CS8; break; 277 } 278 if (l & CSTOPB) r |= IBCS2_CSTOPB; 279 if (l & CREAD) r |= IBCS2_CREAD; 280 if (l & PARENB) r |= IBCS2_PARENB; 281 if (l & PARODD) r |= IBCS2_PARODD; 282 if (l & HUPCL) r |= IBCS2_HUPCL; 283 if (l & CLOCAL) r |= IBCS2_CLOCAL; 284 st->c_cflag = r; 285 286 l = bt->c_lflag; r = 0; 287 if (l & ISIG) r |= IBCS2_ISIG; 288 if (l & ICANON) r |= IBCS2_ICANON; 289 if (l & ECHO) r |= IBCS2_ECHO; 290 if (l & ECHOE) r |= IBCS2_ECHOE; 291 if (l & ECHOK) r |= IBCS2_ECHOK; 292 if (l & ECHONL) r |= IBCS2_ECHONL; 293 if (l & NOFLSH) r |= IBCS2_NOFLSH; 294 if (l & TOSTOP) r |= IBCS2_TOSTOP; 295 st->c_lflag = r; 296 297 l = ttspeedtab(bt->c_ospeed, sptab); 298 if ((int)l >= 0) 299 st->c_cflag |= l; 300 301 st->c_cc[IBCS2_VINTR] = 302 bt->c_cc[VINTR] != _POSIX_VDISABLE ? bt->c_cc[VINTR] : 0; 303 st->c_cc[IBCS2_VQUIT] = 304 bt->c_cc[VQUIT] != _POSIX_VDISABLE ? bt->c_cc[VQUIT] : 0; 305 st->c_cc[IBCS2_VERASE] = 306 bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0; 307 st->c_cc[IBCS2_VKILL] = 308 bt->c_cc[VKILL] != _POSIX_VDISABLE ? bt->c_cc[VKILL] : 0; 309 if (bt->c_lflag & ICANON) { 310 st->c_cc[IBCS2_VEOF] = 311 bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0; 312 st->c_cc[IBCS2_VEOL] = 313 bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0; 314 } else { 315 st->c_cc[IBCS2_VMIN] = bt->c_cc[VMIN]; 316 st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME]; 317 } 318 st->c_cc[IBCS2_VEOL2] = 319 bt->c_cc[VEOL2] != _POSIX_VDISABLE ? bt->c_cc[VEOL2] : 0; 320 st->c_cc[IBCS2_VSWTCH] = 321 0; 322 st->c_cc[IBCS2_VSUSP] = 323 bt->c_cc[VSUSP] != _POSIX_VDISABLE ? bt->c_cc[VSUSP] : 0; 324 st->c_cc[IBCS2_VSTART] = 325 bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0; 326 st->c_cc[IBCS2_VSTOP] = 327 bt->c_cc[VSTOP] != _POSIX_VDISABLE ? bt->c_cc[VSTOP] : 0; 328 329 st->c_line = 0; 330 } 331 332 static void 333 stios2stio(ts, t) 334 struct ibcs2_termios *ts; 335 struct ibcs2_termio *t; 336 { 337 t->c_iflag = ts->c_iflag; 338 t->c_oflag = ts->c_oflag; 339 t->c_cflag = ts->c_cflag; 340 t->c_lflag = ts->c_lflag; 341 t->c_line = ts->c_line; 342 bcopy(ts->c_cc, t->c_cc, IBCS2_NCC); 343 } 344 345 static void 346 stio2stios(t, ts) 347 struct ibcs2_termio *t; 348 struct ibcs2_termios *ts; 349 { 350 ts->c_iflag = t->c_iflag; 351 ts->c_oflag = t->c_oflag; 352 ts->c_cflag = t->c_cflag; 353 ts->c_lflag = t->c_lflag; 354 ts->c_line = t->c_line; 355 bcopy(t->c_cc, ts->c_cc, IBCS2_NCC); 356 } 357 358 int 359 ibcs2_ioctl(p, uap, retval) 360 struct proc *p; 361 struct ibcs2_ioctl_args *uap; 362 int *retval; 363 { 364 struct filedesc *fdp = p->p_fd; 365 struct file *fp; 366 int (*ctl) __P((struct file *, int, caddr_t, struct proc *)); 367 int error; 368 369 if (SCARG(uap, fd) < 0 || SCARG(uap, fd) >= fdp->fd_nfiles || 370 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) { 371 DPRINTF(("ibcs2_ioctl(%d): bad fd %d ", p->p_pid, 372 SCARG(uap, fd))); 373 return EBADF; 374 } 375 376 if ((fp->f_flag & (FREAD|FWRITE)) == 0) { 377 DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid)); 378 return EBADF; 379 } 380 381 ctl = fp->f_ops->fo_ioctl; 382 383 switch (SCARG(uap, cmd)) { 384 case IBCS2_TCGETA: 385 case IBCS2_XCGETA: 386 case IBCS2_OXCGETA: 387 { 388 struct termios bts; 389 struct ibcs2_termios sts; 390 struct ibcs2_termio st; 391 392 if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) 393 return error; 394 395 btios2stios (&bts, &sts); 396 if (SCARG(uap, cmd) == IBCS2_TCGETA) { 397 stios2stio (&sts, &st); 398 error = copyout((caddr_t)&st, SCARG(uap, data), 399 sizeof (st)); 400 #ifdef DEBUG_IBCS2 401 if (error) 402 DPRINTF(("ibcs2_ioctl(%d): copyout failed ", 403 p->p_pid)); 404 #endif 405 return error; 406 } else 407 return copyout((caddr_t)&sts, SCARG(uap, data), 408 sizeof (sts)); 409 /*NOTREACHED*/ 410 } 411 412 case IBCS2_TCSETA: 413 case IBCS2_TCSETAW: 414 case IBCS2_TCSETAF: 415 { 416 struct termios bts; 417 struct ibcs2_termios sts; 418 struct ibcs2_termio st; 419 420 if ((error = copyin(SCARG(uap, data), (caddr_t)&st, 421 sizeof(st))) != 0) { 422 DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ", 423 p->p_pid)); 424 return error; 425 } 426 427 /* get full BSD termios so we don't lose information */ 428 if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) { 429 DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ", 430 p->p_pid, SCARG(uap, fd))); 431 return error; 432 } 433 434 /* 435 * convert to iBCS2 termios, copy in information from 436 * termio, and convert back, then set new values. 437 */ 438 btios2stios(&bts, &sts); 439 stio2stios(&st, &sts); 440 stios2btios(&sts, &bts); 441 442 return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA, 443 (caddr_t)&bts, p); 444 } 445 446 case IBCS2_XCSETA: 447 case IBCS2_XCSETAW: 448 case IBCS2_XCSETAF: 449 { 450 struct termios bts; 451 struct ibcs2_termios sts; 452 453 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts, 454 sizeof (sts))) != 0) { 455 return error; 456 } 457 stios2btios (&sts, &bts); 458 return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA, 459 (caddr_t)&bts, p); 460 } 461 462 case IBCS2_OXCSETA: 463 case IBCS2_OXCSETAW: 464 case IBCS2_OXCSETAF: 465 { 466 struct termios bts; 467 struct ibcs2_termios sts; 468 469 if ((error = copyin(SCARG(uap, data), (caddr_t)&sts, 470 sizeof (sts))) != 0) { 471 return error; 472 } 473 stios2btios (&sts, &bts); 474 return (*ctl)(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA, 475 (caddr_t)&bts, p); 476 } 477 478 case IBCS2_TCSBRK: 479 DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid)); 480 return ENOSYS; 481 482 case IBCS2_TCXONC: 483 { 484 switch ((int)SCARG(uap, data)) { 485 case 0: 486 case 1: 487 DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid)); 488 return ENOSYS; 489 case 2: 490 return (*ctl)(fp, TIOCSTOP, (caddr_t)0, p); 491 case 3: 492 return (*ctl)(fp, TIOCSTART, (caddr_t)1, p); 493 default: 494 return EINVAL; 495 } 496 } 497 498 case IBCS2_TCFLSH: 499 { 500 int arg; 501 502 switch ((int)SCARG(uap, data)) { 503 case 0: 504 arg = FREAD; 505 break; 506 case 1: 507 arg = FWRITE; 508 break; 509 case 2: 510 arg = FREAD | FWRITE; 511 break; 512 default: 513 return EINVAL; 514 } 515 return (*ctl)(fp, TIOCFLUSH, (caddr_t)&arg, p); 516 } 517 518 case IBCS2_TIOCGWINSZ: 519 SCARG(uap, cmd) = TIOCGWINSZ; 520 return ioctl(p, (struct ioctl_args *)uap, retval); 521 522 case IBCS2_TIOCSWINSZ: 523 SCARG(uap, cmd) = TIOCSWINSZ; 524 return ioctl(p, (struct ioctl_args *)uap, retval); 525 526 case IBCS2_TIOCGPGRP: 527 return copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data), 528 sizeof(p->p_pgrp->pg_id)); 529 530 case IBCS2_TIOCSPGRP: /* XXX - is uap->data a pointer to pgid? */ 531 { 532 struct setpgid_args sa; 533 534 SCARG(&sa, pid) = 0; 535 SCARG(&sa, pgid) = (int)SCARG(uap, data); 536 if (error = setpgid(p, &sa, retval)) 537 return error; 538 return 0; 539 } 540 541 case IBCS2_TCGETSC: /* SCO console - get scancode flags */ 542 return EINTR; /* ENOSYS; */ 543 544 case IBCS2_TCSETSC: /* SCO console - set scancode flags */ 545 return 0; /* ENOSYS; */ 546 547 case IBCS2_JWINSIZE: /* Unix to Jerq I/O control */ 548 { 549 struct ibcs2_jwinsize { 550 char bytex, bytey; 551 short bitx, bity; 552 } ibcs2_jwinsize; 553 554 ibcs2_jwinsize.bytex = 80; 555 /* p->p_session->s_ttyp->t_winsize.ws_col; XXX */ 556 ibcs2_jwinsize.bytey = 25; 557 /* p->p_session->s_ttyp->t_winsize.ws_row; XXX */ 558 ibcs2_jwinsize.bitx = 559 p->p_session->s_ttyp->t_winsize.ws_xpixel; 560 ibcs2_jwinsize.bity = 561 p->p_session->s_ttyp->t_winsize.ws_ypixel; 562 return copyout((caddr_t)&ibcs2_jwinsize, SCARG(uap, data), 563 sizeof(ibcs2_jwinsize)); 564 } 565 566 /* keyboard and display ioctl's -- type 'K' */ 567 case IBCS2_KDGKBMODE: /* get keyboard translation mode */ 568 SCARG(uap, cmd) = KDGKBMODE; 569 /* printf("ioctl KDGKBMODE = %x\n", SCARG(uap, cmd));*/ 570 return ioctl(p, (struct ioctl_args *)uap, retval); 571 572 case IBCS2_KDSKBMODE: /* set keyboard translation mode */ 573 SCARG(uap, cmd) = KDSKBMODE; 574 return ioctl(p, (struct ioctl_args *)uap, retval); 575 576 case IBCS2_KDMKTONE: /* sound tone */ 577 SCARG(uap, cmd) = KDMKTONE; 578 return ioctl(p, (struct ioctl_args *)uap, retval); 579 580 case IBCS2_KDGETMODE: /* get text/graphics mode */ 581 SCARG(uap, cmd) = KDGETMODE; 582 return ioctl(p, (struct ioctl_args *)uap, retval); 583 584 case IBCS2_KDSETMODE: /* set text/graphics mode */ 585 SCARG(uap, cmd) = KDSETMODE; 586 return ioctl(p, (struct ioctl_args *)uap, retval); 587 588 case IBCS2_KDSBORDER: /* set ega color border */ 589 SCARG(uap, cmd) = KDSBORDER; 590 return ioctl(p, (struct ioctl_args *)uap, retval); 591 592 case IBCS2_KDGKBSTATE: 593 SCARG(uap, cmd) = KDGKBSTATE; 594 return ioctl(p, (struct ioctl_args *)uap, retval); 595 596 case IBCS2_KDSETRAD: 597 SCARG(uap, cmd) = KDSETRAD; 598 return ioctl(p, (struct ioctl_args *)uap, retval); 599 600 case IBCS2_KDENABIO: /* enable direct I/O to ports */ 601 SCARG(uap, cmd) = KDENABIO; 602 return ioctl(p, (struct ioctl_args *)uap, retval); 603 604 case IBCS2_KDDISABIO: /* disable direct I/O to ports */ 605 SCARG(uap, cmd) = KDDISABIO; 606 return ioctl(p, (struct ioctl_args *)uap, retval); 607 608 case IBCS2_KIOCSOUND: /* start sound generation */ 609 SCARG(uap, cmd) = KIOCSOUND; 610 return ioctl(p, (struct ioctl_args *)uap, retval); 611 612 case IBCS2_KDGKBTYPE: /* get keyboard type */ 613 SCARG(uap, cmd) = KDGKBTYPE; 614 return ioctl(p, (struct ioctl_args *)uap, retval); 615 616 case IBCS2_KDGETLED: /* get keyboard LED status */ 617 SCARG(uap, cmd) = KDGETLED; 618 return ioctl(p, (struct ioctl_args *)uap, retval); 619 620 case IBCS2_KDSETLED: /* set keyboard LED status */ 621 SCARG(uap, cmd) = KDSETLED; 622 return ioctl(p, (struct ioctl_args *)uap, retval); 623 624 /* Xenix keyboard and display ioctl's from sys/kd.h -- type 'k' */ 625 case IBCS2_GETFKEY: /* Get function key */ 626 SCARG(uap, cmd) = GETFKEY; 627 return ioctl(p, (struct ioctl_args *)uap, retval); 628 629 case IBCS2_SETFKEY: /* Set function key */ 630 SCARG(uap, cmd) = SETFKEY; 631 return ioctl(p, (struct ioctl_args *)uap, retval); 632 633 case IBCS2_GIO_SCRNMAP: /* Get screen output map table */ 634 SCARG(uap, cmd) = GIO_SCRNMAP; 635 return ioctl(p, (struct ioctl_args *)uap, retval); 636 637 case IBCS2_PIO_SCRNMAP: /* Set screen output map table */ 638 SCARG(uap, cmd) = PIO_SCRNMAP; 639 return ioctl(p, (struct ioctl_args *)uap, retval); 640 641 case IBCS2_GIO_KEYMAP: /* Get keyboard map table */ 642 SCARG(uap, cmd) = GIO_KEYMAP; 643 return ioctl(p, (struct ioctl_args *)uap, retval); 644 645 case IBCS2_PIO_KEYMAP: /* Set keyboard map table */ 646 SCARG(uap, cmd) = PIO_KEYMAP; 647 return ioctl(p, (struct ioctl_args *)uap, retval); 648 649 /* socksys */ 650 case IBCS2_SIOCSOCKSYS: 651 return ibcs2_socksys(p, (struct ibcs2_socksys_args *)uap, 652 retval); 653 654 case IBCS2_I_NREAD: /* STREAMS */ 655 SCARG(uap, cmd) = FIONREAD; 656 return ioctl(p, (struct ioctl_args *)uap, retval); 657 658 default: 659 DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ", 660 p->p_pid, SCARG(uap, cmd))); 661 return ENOSYS; 662 } 663 return ENOSYS; 664 }
Cache object: 718d0d251724b96c2985bee5137bff18
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]