![[BACK]](/icons/back.gif){kind=icon}
Return to ibcs2_ioctl.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / ibcs2|
Return to ibcs2_ioctl.c CVS log | Up to [local] / sys / compat / ibcs2 |
1.1 nbrk 1: /* $OpenBSD: ibcs2_ioctl.c,v 1.12 2004/09/19 21:34:42 mickey Exp $ */
2: /* $NetBSD: ibcs2_ioctl.c,v 1.12 1996/08/10 09:08:26 mycroft Exp $ */
3:
4: /*
5: * Copyright (c) 1994, 1995 Scott Bartram
6: * All rights reserved.
7: *
8: * based on compat/sunos/sun_ioctl.c
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28: */
29:
30: #include <sys/param.h>
31: #include <sys/systm.h>
32: #include <sys/namei.h>
33: #include <sys/dirent.h>
34: #include <sys/proc.h>
35: #include <sys/file.h>
36: #include <sys/stat.h>
37: #include <sys/filedesc.h>
38: #include <sys/ioctl.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:
60: #include <net/if.h>
61: #include <sys/syscallargs.h>
62:
63: #include <compat/ibcs2/ibcs2_types.h>
64: #include <compat/ibcs2/ibcs2_signal.h>
65: #include <compat/ibcs2/ibcs2_socksys.h>
66: #include <compat/ibcs2/ibcs2_stropts.h>
67: #include <compat/ibcs2/ibcs2_syscallargs.h>
68: #include <compat/ibcs2/ibcs2_termios.h>
69: #include <compat/ibcs2/ibcs2_util.h>
70:
71: /*
72: * iBCS2 ioctl calls.
73: */
74:
75: static const struct speedtab sptab[] = {
76: { 0, 0 },
77: { 50, 1 },
78: { 75, 2 },
79: { 110, 3 },
80: { 134, 4 },
81: { 135, 4 },
82: { 150, 5 },
83: { 200, 6 },
84: { 300, 7 },
85: { 600, 8 },
86: { 1200, 9 },
87: { 1800, 10 },
88: { 2400, 11 },
89: { 4800, 12 },
90: { 9600, 13 },
91: { 19200, 14 },
92: { 38400, 15 },
93: { -1, -1 }
94: };
95:
96: static const u_long s2btab[] = {
97: 0,
98: 50,
99: 75,
100: 110,
101: 134,
102: 150,
103: 200,
104: 300,
105: 600,
106: 1200,
107: 1800,
108: 2400,
109: 4800,
110: 9600,
111: 19200,
112: 38400,
113: };
114:
115: static void stios2btios(struct ibcs2_termios *, struct termios *);
116: static void btios2stios(struct termios *, struct ibcs2_termios *);
117: static void stios2stio(struct ibcs2_termios *, struct ibcs2_termio *);
118: static void stio2stios(struct ibcs2_termio *, struct ibcs2_termios *);
119:
120: static void
121: stios2btios(st, bt)
122: struct ibcs2_termios *st;
123: struct termios *bt;
124: {
125: register u_long l, r;
126:
127: l = st->c_iflag; r = 0;
128: if (l & IBCS2_IGNBRK) r |= IGNBRK;
129: if (l & IBCS2_BRKINT) r |= BRKINT;
130: if (l & IBCS2_IGNPAR) r |= IGNPAR;
131: if (l & IBCS2_PARMRK) r |= PARMRK;
132: if (l & IBCS2_INPCK) r |= INPCK;
133: if (l & IBCS2_ISTRIP) r |= ISTRIP;
134: if (l & IBCS2_INLCR) r |= INLCR;
135: if (l & IBCS2_IGNCR) r |= IGNCR;
136: if (l & IBCS2_ICRNL) r |= ICRNL;
137: if (l & IBCS2_IXON) r |= IXON;
138: if (l & IBCS2_IXANY) r |= IXANY;
139: if (l & IBCS2_IXOFF) r |= IXOFF;
140: if (l & IBCS2_IMAXBEL) r |= IMAXBEL;
141: bt->c_iflag = r;
142:
143: l = st->c_oflag; r = 0;
144: if (l & IBCS2_OPOST) r |= OPOST;
145: if (l & IBCS2_ONLCR) r |= ONLCR;
146: if (l & IBCS2_TAB3) r |= OXTABS;
147: bt->c_oflag = r;
148:
149: l = st->c_cflag; r = 0;
150: switch (l & IBCS2_CSIZE) {
151: case IBCS2_CS5: r |= CS5; break;
152: case IBCS2_CS6: r |= CS6; break;
153: case IBCS2_CS7: r |= CS7; break;
154: case IBCS2_CS8: r |= CS8; break;
155: }
156: if (l & IBCS2_CSTOPB) r |= CSTOPB;
157: if (l & IBCS2_CREAD) r |= CREAD;
158: if (l & IBCS2_PARENB) r |= PARENB;
159: if (l & IBCS2_PARODD) r |= PARODD;
160: if (l & IBCS2_HUPCL) r |= HUPCL;
161: if (l & IBCS2_CLOCAL) r |= CLOCAL;
162: bt->c_cflag = r;
163:
164: l = st->c_lflag; r = 0;
165: if (l & IBCS2_ISIG) r |= ISIG;
166: if (l & IBCS2_ICANON) r |= ICANON;
167: if (l & IBCS2_ECHO) r |= ECHO;
168: if (l & IBCS2_ECHOE) r |= ECHOE;
169: if (l & IBCS2_ECHOK) r |= ECHOK;
170: if (l & IBCS2_ECHONL) r |= ECHONL;
171: if (l & IBCS2_NOFLSH) r |= NOFLSH;
172: if (l & IBCS2_TOSTOP) r |= TOSTOP;
173: bt->c_lflag = r;
174:
175: bt->c_ispeed = bt->c_ospeed = s2btab[l & 0x0000000f];
176:
177: bt->c_cc[VINTR] =
178: st->c_cc[IBCS2_VINTR] ? st->c_cc[IBCS2_VINTR] : _POSIX_VDISABLE;
179: bt->c_cc[VQUIT] =
180: st->c_cc[IBCS2_VQUIT] ? st->c_cc[IBCS2_VQUIT] : _POSIX_VDISABLE;
181: bt->c_cc[VERASE] =
182: st->c_cc[IBCS2_VERASE] ? st->c_cc[IBCS2_VERASE] : _POSIX_VDISABLE;
183: bt->c_cc[VKILL] =
184: st->c_cc[IBCS2_VKILL] ? st->c_cc[IBCS2_VKILL] : _POSIX_VDISABLE;
185: if (bt->c_lflag & ICANON) {
186: bt->c_cc[VEOF] =
187: st->c_cc[IBCS2_VEOF] ? st->c_cc[IBCS2_VEOF] : _POSIX_VDISABLE;
188: bt->c_cc[VEOL] =
189: st->c_cc[IBCS2_VEOL] ? st->c_cc[IBCS2_VEOL] : _POSIX_VDISABLE;
190: } else {
191: bt->c_cc[VMIN] = st->c_cc[IBCS2_VMIN];
192: bt->c_cc[VTIME] = st->c_cc[IBCS2_VTIME];
193: }
194: bt->c_cc[VEOL2] =
195: st->c_cc[IBCS2_VEOL2] ? st->c_cc[IBCS2_VEOL2] : _POSIX_VDISABLE;
196: #if 0
197: bt->c_cc[VSWTCH] =
198: st->c_cc[IBCS2_VSWTCH] ? st->c_cc[IBCS2_VSWTCH] : _POSIX_VDISABLE;
199: #endif
200: bt->c_cc[VSTART] =
201: st->c_cc[IBCS2_VSTART] ? st->c_cc[IBCS2_VSTART] : _POSIX_VDISABLE;
202: bt->c_cc[VSTOP] =
203: st->c_cc[IBCS2_VSTOP] ? st->c_cc[IBCS2_VSTOP] : _POSIX_VDISABLE;
204: bt->c_cc[VSUSP] =
205: st->c_cc[IBCS2_VSUSP] ? st->c_cc[IBCS2_VSUSP] : _POSIX_VDISABLE;
206: bt->c_cc[VDSUSP] = _POSIX_VDISABLE;
207: bt->c_cc[VREPRINT] = _POSIX_VDISABLE;
208: bt->c_cc[VDISCARD] = _POSIX_VDISABLE;
209: bt->c_cc[VWERASE] = _POSIX_VDISABLE;
210: bt->c_cc[VLNEXT] = _POSIX_VDISABLE;
211: bt->c_cc[VSTATUS] = _POSIX_VDISABLE;
212: }
213:
214: static void
215: btios2stios(bt, st)
216: struct termios *bt;
217: struct ibcs2_termios *st;
218: {
219: register u_long l, r;
220:
221: l = bt->c_iflag; r = 0;
222: if (l & IGNBRK) r |= IBCS2_IGNBRK;
223: if (l & BRKINT) r |= IBCS2_BRKINT;
224: if (l & IGNPAR) r |= IBCS2_IGNPAR;
225: if (l & PARMRK) r |= IBCS2_PARMRK;
226: if (l & INPCK) r |= IBCS2_INPCK;
227: if (l & ISTRIP) r |= IBCS2_ISTRIP;
228: if (l & INLCR) r |= IBCS2_INLCR;
229: if (l & IGNCR) r |= IBCS2_IGNCR;
230: if (l & ICRNL) r |= IBCS2_ICRNL;
231: if (l & IXON) r |= IBCS2_IXON;
232: if (l & IXANY) r |= IBCS2_IXANY;
233: if (l & IXOFF) r |= IBCS2_IXOFF;
234: if (l & IMAXBEL) r |= IBCS2_IMAXBEL;
235: st->c_iflag = r;
236:
237: l = bt->c_oflag; r = 0;
238: if (l & OPOST) r |= IBCS2_OPOST;
239: if (l & ONLCR) r |= IBCS2_ONLCR;
240: if (l & OXTABS) r |= IBCS2_TAB3;
241: st->c_oflag = r;
242:
243: l = bt->c_cflag; r = 0;
244: switch (l & CSIZE) {
245: case CS5: r |= IBCS2_CS5; break;
246: case CS6: r |= IBCS2_CS6; break;
247: case CS7: r |= IBCS2_CS7; break;
248: case CS8: r |= IBCS2_CS8; break;
249: }
250: if (l & CSTOPB) r |= IBCS2_CSTOPB;
251: if (l & CREAD) r |= IBCS2_CREAD;
252: if (l & PARENB) r |= IBCS2_PARENB;
253: if (l & PARODD) r |= IBCS2_PARODD;
254: if (l & HUPCL) r |= IBCS2_HUPCL;
255: if (l & CLOCAL) r |= IBCS2_CLOCAL;
256: st->c_cflag = r;
257:
258: l = bt->c_lflag; r = 0;
259: if (l & ISIG) r |= IBCS2_ISIG;
260: if (l & ICANON) r |= IBCS2_ICANON;
261: if (l & ECHO) r |= IBCS2_ECHO;
262: if (l & ECHOE) r |= IBCS2_ECHOE;
263: if (l & ECHOK) r |= IBCS2_ECHOK;
264: if (l & ECHONL) r |= IBCS2_ECHONL;
265: if (l & NOFLSH) r |= IBCS2_NOFLSH;
266: if (l & TOSTOP) r |= IBCS2_TOSTOP;
267: st->c_lflag = r;
268:
269: l = ttspeedtab(bt->c_ospeed, sptab);
270: if (l >= 0)
271: st->c_cflag |= l;
272:
273: st->c_cc[IBCS2_VINTR] =
274: bt->c_cc[VINTR] != _POSIX_VDISABLE ? bt->c_cc[VINTR] : 0;
275: st->c_cc[IBCS2_VQUIT] =
276: bt->c_cc[VQUIT] != _POSIX_VDISABLE ? bt->c_cc[VQUIT] : 0;
277: st->c_cc[IBCS2_VERASE] =
278: bt->c_cc[VERASE] != _POSIX_VDISABLE ? bt->c_cc[VERASE] : 0;
279: st->c_cc[IBCS2_VKILL] =
280: bt->c_cc[VKILL] != _POSIX_VDISABLE ? bt->c_cc[VKILL] : 0;
281: if (bt->c_lflag & ICANON) {
282: st->c_cc[IBCS2_VEOF] =
283: bt->c_cc[VEOF] != _POSIX_VDISABLE ? bt->c_cc[VEOF] : 0;
284: st->c_cc[IBCS2_VEOL] =
285: bt->c_cc[VEOL] != _POSIX_VDISABLE ? bt->c_cc[VEOL] : 0;
286: } else {
287: st->c_cc[IBCS2_VMIN] = bt->c_cc[VMIN];
288: st->c_cc[IBCS2_VTIME] = bt->c_cc[VTIME];
289: }
290: st->c_cc[IBCS2_VEOL2] =
291: bt->c_cc[VEOL2] != _POSIX_VDISABLE ? bt->c_cc[VEOL2] : 0;
292: st->c_cc[IBCS2_VSWTCH] =
293: 0;
294: st->c_cc[IBCS2_VSUSP] =
295: bt->c_cc[VSUSP] != _POSIX_VDISABLE ? bt->c_cc[VSUSP] : 0;
296: st->c_cc[IBCS2_VSTART] =
297: bt->c_cc[VSTART] != _POSIX_VDISABLE ? bt->c_cc[VSTART] : 0;
298: st->c_cc[IBCS2_VSTOP] =
299: bt->c_cc[VSTOP] != _POSIX_VDISABLE ? bt->c_cc[VSTOP] : 0;
300:
301: st->c_line = 0;
302: }
303:
304: static void
305: stios2stio(ts, t)
306: struct ibcs2_termios *ts;
307: struct ibcs2_termio *t;
308: {
309:
310: t->c_iflag = ts->c_iflag;
311: t->c_oflag = ts->c_oflag;
312: t->c_cflag = ts->c_cflag;
313: t->c_lflag = ts->c_lflag;
314: t->c_line = ts->c_line;
315: bcopy(ts->c_cc, t->c_cc, IBCS2_NCC);
316: }
317:
318: static void
319: stio2stios(t, ts)
320: struct ibcs2_termio *t;
321: struct ibcs2_termios *ts;
322: {
323:
324: ts->c_iflag = t->c_iflag;
325: ts->c_oflag = t->c_oflag;
326: ts->c_cflag = t->c_cflag;
327: ts->c_lflag = t->c_lflag;
328: ts->c_line = t->c_line;
329: bcopy(t->c_cc, ts->c_cc, IBCS2_NCC);
330: }
331:
332: int
333: ibcs2_sys_ioctl(p, v, retval)
334: struct proc *p;
335: void *v;
336: register_t *retval;
337: {
338: struct ibcs2_sys_ioctl_args /* {
339: syscallarg(int) fd;
340: syscallarg(int) cmd;
341: syscallarg(caddr_t) data;
342: } */ *uap = v;
343: struct filedesc *fdp = p->p_fd;
344: struct file *fp;
345: int (*ctl)(struct file *, u_long, caddr_t, struct proc *);
346: int error;
347:
348: if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
349: return (EBADF);
350: FREF(fp);
351:
352: if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
353: DPRINTF(("ibcs2_ioctl(%d): bad fp flag ", p->p_pid));
354: error = EBADF;
355: goto out;
356: }
357:
358: ctl = fp->f_ops->fo_ioctl;
359:
360: switch (SCARG(uap, cmd)) {
361: case IBCS2_TCGETA:
362: case IBCS2_XCGETA:
363: case IBCS2_OXCGETA:
364: {
365: struct termios bts;
366: struct ibcs2_termios sts;
367: struct ibcs2_termio st;
368:
369: if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0)
370: goto out;
371:
372: btios2stios (&bts, &sts);
373: if (SCARG(uap, cmd) == IBCS2_TCGETA) {
374: stios2stio (&sts, &st);
375: error = copyout((caddr_t)&st, SCARG(uap, data),
376: sizeof (st));
377: if (error)
378: DPRINTF(("ibcs2_ioctl(%d): copyout failed ",
379: p->p_pid));
380: goto out;
381: } else {
382: error = copyout((caddr_t)&sts, SCARG(uap, data),
383: sizeof (sts));
384: goto out;
385: }
386: /*NOTREACHED*/
387: }
388:
389: case IBCS2_TCSETA:
390: case IBCS2_TCSETAW:
391: case IBCS2_TCSETAF:
392: {
393: struct termios bts;
394: struct ibcs2_termios sts;
395: struct ibcs2_termio st;
396:
397: if ((error = copyin(SCARG(uap, data), (caddr_t)&st,
398: sizeof(st))) != 0) {
399: DPRINTF(("ibcs2_ioctl(%d): TCSET copyin failed ",
400: p->p_pid));
401: goto out;
402: }
403:
404: /* get full BSD termios so we don't lose information */
405: if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bts, p)) != 0) {
406: DPRINTF(("ibcs2_ioctl(%d): TCSET ctl failed fd %d ",
407: p->p_pid, SCARG(uap, fd)));
408: goto out;
409: }
410:
411: /*
412: * convert to iBCS2 termios, copy in information from
413: * termio, and convert back, then set new values.
414: */
415: btios2stios(&bts, &sts);
416: stio2stios(&st, &sts);
417: stios2btios(&sts, &bts);
418:
419: error = (*ctl)(fp, SCARG(uap, cmd) - IBCS2_TCSETA + TIOCSETA,
420: (caddr_t)&bts, p);
421: goto out;
422: }
423:
424: case IBCS2_XCSETA:
425: case IBCS2_XCSETAW:
426: case IBCS2_XCSETAF:
427: {
428: struct termios bts;
429: struct ibcs2_termios sts;
430:
431: if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
432: sizeof (sts))) != 0) {
433: goto out;
434: }
435: stios2btios (&sts, &bts);
436: error = (*ctl)(fp, SCARG(uap, cmd) - IBCS2_XCSETA + TIOCSETA,
437: (caddr_t)&bts, p);
438: goto out;
439: }
440:
441: case IBCS2_OXCSETA:
442: case IBCS2_OXCSETAW:
443: case IBCS2_OXCSETAF:
444: {
445: struct termios bts;
446: struct ibcs2_termios sts;
447:
448: if ((error = copyin(SCARG(uap, data), (caddr_t)&sts,
449: sizeof (sts))) != 0) {
450: goto out;
451: }
452: stios2btios (&sts, &bts);
453: error = (*ctl)(fp, SCARG(uap, cmd) - IBCS2_OXCSETA + TIOCSETA,
454: (caddr_t)&bts, p);
455: goto out;
456: }
457:
458: case IBCS2_TCSBRK:
459: DPRINTF(("ibcs2_ioctl(%d): TCSBRK ", p->p_pid));
460: error = ENOSYS;
461: goto out;
462:
463: case IBCS2_TCXONC:
464: {
465: switch ((int)SCARG(uap, data)) {
466: case 0:
467: case 1:
468: DPRINTF(("ibcs2_ioctl(%d): TCXONC ", p->p_pid));
469: error = ENOSYS;
470: goto out;
471: case 2:
472: error = (*ctl)(fp, TIOCSTOP, (caddr_t)0, p);
473: goto out;
474: case 3:
475: error = (*ctl)(fp, TIOCSTART, (caddr_t)1, p);
476: goto out;
477: default:
478: error = EINVAL;
479: goto out;
480: }
481: }
482:
483: case IBCS2_TCFLSH:
484: {
485: int arg;
486:
487: switch ((int)SCARG(uap, data)) {
488: case 0:
489: arg = FREAD;
490: break;
491: case 1:
492: arg = FWRITE;
493: break;
494: case 2:
495: arg = FREAD | FWRITE;
496: break;
497: default:
498: error = EINVAL;
499: goto out;
500: }
501: error = (*ctl)(fp, TIOCFLUSH, (caddr_t)&arg, p);
502: goto out;
503: }
504:
505: case IBCS2_TIOCGWINSZ:
506: SCARG(uap, cmd) = TIOCGWINSZ;
507: error = sys_ioctl(p, uap, retval);
508: goto out;
509:
510: case IBCS2_TIOCSWINSZ:
511: SCARG(uap, cmd) = TIOCSWINSZ;
512: error = sys_ioctl(p, uap, retval);
513: goto out;
514:
515: case IBCS2_TIOCGPGRP:
516: error = copyout((caddr_t)&p->p_pgrp->pg_id, SCARG(uap, data),
517: sizeof(p->p_pgrp->pg_id));
518: goto out;
519:
520: case IBCS2_TIOCSPGRP: /* XXX - is uap->data a pointer to pgid? */
521: {
522: struct sys_setpgid_args sa;
523:
524: SCARG(&sa, pid) = 0;
525: SCARG(&sa, pgid) = (int)SCARG(uap, data);
526: if ((error = sys_setpgid(p, &sa, retval)) != 0)
527: goto out;
528: error = 0;
529: goto out;
530: }
531:
532: case IBCS2_TCGETSC: /* SCO console - get scancode flags */
533: error = ENOSYS;
534: goto out;
535:
536: case IBCS2_TCSETSC: /* SCO console - set scancode flags */
537: error = ENOSYS;
538: goto out;
539:
540: case IBCS2_SIOCSOCKSYS:
541: error = ibcs2_socksys(p, uap, retval);
542: goto out;
543:
544: case IBCS2_FIONBIO:
545: {
546: int arg;
547:
548: if ((error = copyin(SCARG(uap, data), &arg,
549: sizeof(arg))) != 0)
550: goto out;
551:
552: error = (*ctl)(fp, FIONBIO, (caddr_t)&arg, p);
553: goto out;
554: }
555: case IBCS2_FIONREAD:
556: case IBCS2_I_NREAD: /* STREAMS */
557: SCARG(uap, cmd) = FIONREAD;
558: error = sys_ioctl(p, uap, retval);
559: goto out;
560:
561: default:
562: DPRINTF(("ibcs2_ioctl(%d): unknown cmd 0x%lx ",
563: p->p_pid, SCARG(uap, cmd)));
564: error = ENOSYS;
565: goto out;
566: }
567: error = ENOSYS;
568:
569: out:
570: FRELE(fp);
571: return (error);
572: }
573: