![[BACK]](/icons/back.gif){kind=icon}
Return to svr4_ttold.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4|
Return to svr4_ttold.c CVS log | Up to [local] / sys / compat / svr4 |
1.1 nbrk 1: /* $OpenBSD: svr4_ttold.c,v 1.7 2002/03/14 01:26:51 millert Exp $ */
2: /* $NetBSD: svr4_ttold.c,v 1.9 1996/04/11 12:54:45 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1994 Christos Zoulas
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. The name of the author may not be used to endorse or promote products
17: * derived from this software without specific prior written permission
18: *
19: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29: */
30:
31: #include <sys/param.h>
32: #include <sys/proc.h>
33: #include <sys/systm.h>
34: #include <sys/file.h>
35: #include <sys/filedesc.h>
36: #include <sys/ioctl.h>
37: #include <sys/termios.h>
38: #include <sys/tty.h>
39: #include <sys/socket.h>
40: #include <sys/mount.h>
41: #include <net/if.h>
42: #include <sys/malloc.h>
43:
44: #include <sys/syscallargs.h>
45:
46: #include <compat/svr4/svr4_types.h>
47: #include <compat/svr4/svr4_util.h>
48: #include <compat/svr4/svr4_signal.h>
49: #include <compat/svr4/svr4_syscallargs.h>
50: #include <compat/svr4/svr4_stropts.h>
51: #include <compat/svr4/svr4_ttold.h>
52: #include <compat/svr4/svr4_ioctl.h>
53:
54: static void svr4_tchars_to_bsd_tchars(const struct svr4_tchars *st,
55: struct tchars *bt);
56: static void bsd_tchars_to_svr4_tchars(const struct tchars *bt,
57: struct svr4_tchars *st);
58: static void svr4_sgttyb_to_bsd_sgttyb(const struct svr4_sgttyb *ss,
59: struct sgttyb *bs);
60: static void bsd_sgttyb_to_svr4_sgttyb(const struct sgttyb *bs,
61: struct svr4_sgttyb *ss);
62: static void svr4_ltchars_to_bsd_ltchars(const struct svr4_ltchars *sl,
63: struct ltchars *bl);
64: static void bsd_ltchars_to_svr4_ltchars(const struct ltchars *bl,
65: struct svr4_ltchars *sl);
66:
67: #ifdef DEBUG_SVR4
68: static void print_svr4_sgttyb(const char *, struct svr4_sgttyb *);
69: static void print_svr4_tchars(const char *, struct svr4_tchars *);
70: static void print_svr4_ltchars(const char *, struct svr4_ltchars *);
71:
72: static void
73: print_svr4_sgttyb(str, ss)
74: const char *str;
75: struct svr4_sgttyb *ss;
76: {
77: uprintf("%s\nispeed=%o ospeed=%o ", str, ss->sg_ispeed, ss->sg_ospeed);
78: uprintf("erase=%o kill=%o flags=%o\n", ss->sg_erase, ss->sg_kill,
79: ss->sg_flags);
80: }
81:
82: static void
83: print_svr4_tchars(str, st)
84: const char *str;
85: struct svr4_tchars *st;
86: {
87: uprintf("%s\nintrc=%o quitc=%o ", str, st->t_intrc, st->t_quitc);
88: uprintf("startc=%o stopc=%o eofc=%o brkc=%o\n", st->t_startc,
89: st->t_stopc, st->t_eofc, st->t_brkc);
90: }
91:
92: static void
93: print_svr4_ltchars(str, sl)
94: const char *str;
95: struct svr4_ltchars *sl;
96: {
97: uprintf("%s\nsuspc=%o dsuspc=%o ", str, sl->t_suspc, sl->t_dsuspc);
98: uprintf("rprntc=%o flushc=%o werasc=%o lnextc=%o\n", sl->t_rprntc,
99: sl->t_flushc, sl->t_werasc, sl->t_lnextc);
100: }
101: #endif /* DEBUG_SVR4 */
102:
103: static void
104: svr4_tchars_to_bsd_tchars(st, bt)
105: const struct svr4_tchars *st;
106: struct tchars *bt;
107: {
108: bt->t_intrc = st->t_intrc;
109: bt->t_quitc = st->t_quitc;
110: bt->t_startc = st->t_startc;
111: bt->t_stopc = st->t_stopc;
112: bt->t_eofc = st->t_eofc;
113: bt->t_brkc = st->t_brkc;
114: }
115:
116:
117: static void
118: bsd_tchars_to_svr4_tchars(bt, st)
119: const struct tchars *bt;
120: struct svr4_tchars *st;
121: {
122: st->t_intrc = bt->t_intrc;
123: st->t_quitc = bt->t_quitc;
124: st->t_startc = bt->t_startc;
125: st->t_stopc = bt->t_stopc;
126: st->t_eofc = bt->t_eofc;
127: st->t_brkc = bt->t_brkc;
128: }
129:
130:
131: static void
132: svr4_sgttyb_to_bsd_sgttyb(ss, bs)
133: const struct svr4_sgttyb *ss;
134: struct sgttyb *bs;
135: {
136: bs->sg_ispeed = ss->sg_ispeed;
137: bs->sg_ospeed = ss->sg_ospeed;
138: bs->sg_erase = ss->sg_erase;
139: bs->sg_kill = ss->sg_kill;
140: bs->sg_flags = ss->sg_flags;
141: };
142:
143:
144: static void
145: bsd_sgttyb_to_svr4_sgttyb(bs, ss)
146: const struct sgttyb *bs;
147: struct svr4_sgttyb *ss;
148: {
149: ss->sg_ispeed = bs->sg_ispeed;
150: ss->sg_ospeed = bs->sg_ospeed;
151: ss->sg_erase = bs->sg_erase;
152: ss->sg_kill = bs->sg_kill;
153: ss->sg_flags = bs->sg_flags;
154: }
155:
156:
157: static void
158: svr4_ltchars_to_bsd_ltchars(sl, bl)
159: const struct svr4_ltchars *sl;
160: struct ltchars *bl;
161: {
162: bl->t_suspc = sl->t_suspc;
163: bl->t_dsuspc = sl->t_dsuspc;
164: bl->t_rprntc = sl->t_rprntc;
165: bl->t_flushc = sl->t_flushc;
166: bl->t_werasc = sl->t_werasc;
167: bl->t_lnextc = sl->t_lnextc;
168: }
169:
170:
171: static void
172: bsd_ltchars_to_svr4_ltchars(bl, sl)
173: const struct ltchars *bl;
174: struct svr4_ltchars *sl;
175: {
176: sl->t_suspc = bl->t_suspc;
177: sl->t_dsuspc = bl->t_dsuspc;
178: sl->t_rprntc = bl->t_rprntc;
179: sl->t_flushc = bl->t_flushc;
180: sl->t_werasc = bl->t_werasc;
181: sl->t_lnextc = bl->t_lnextc;
182: }
183:
184:
185: int
186: svr4_ttold_ioctl(fp, p, retval, fd, cmd, data)
187: struct file *fp;
188: struct proc *p;
189: register_t *retval;
190: int fd;
191: u_long cmd;
192: caddr_t data;
193: {
194: int error;
195: int (*ctl)(struct file *, u_long, caddr_t, struct proc *) =
196: fp->f_ops->fo_ioctl;
197:
198: *retval = 0;
199:
200: switch (cmd) {
201: case SVR4_TIOCGPGRP:
202: {
203: pid_t pid;
204:
205: if ((error = (*ctl)(fp, TIOCGPGRP,
206: (caddr_t) &pid, p)) != 0)
207: return error;
208:
209: DPRINTF(("TIOCGPGRP %d\n", pid));
210:
211: if ((error = copyout(&pid, data, sizeof(pid))) != 0)
212: return error;
213:
214: }
215:
216: case SVR4_TIOCSPGRP:
217: {
218: pid_t pid;
219:
220: if ((error = copyin(data, &pid, sizeof(pid))) != 0)
221: return error;
222:
223: DPRINTF(("TIOCSPGRP %d\n", pid));
224:
225: return (*ctl)(fp, TIOCSPGRP, (caddr_t) &pid, p);
226: }
227:
228: case SVR4_TIOCGSID:
229: {
230: pid_t pid;
231:
232: if ((error = (*ctl)(fp, TIOCGSID,
233: (caddr_t) &pid, p)) != 0)
234: return error;
235:
236: DPRINTF(("TIOCGSID %d\n", pid));
237:
238: return copyout(&pid, data, sizeof(pid));
239: }
240:
241: case SVR4_TIOCGETP:
242: {
243: struct sgttyb bs;
244: struct svr4_sgttyb ss;
245:
246: error = (*ctl)(fp, TIOCGETP, (caddr_t) &bs, p);
247: if (error)
248: return error;
249:
250: bsd_sgttyb_to_svr4_sgttyb(&bs, &ss);
251: #ifdef DEBUG_SVR4
252: print_svr4_sgttyb("SVR4_TIOCGETP", &ss);
253: #endif /* DEBUG_SVR4 */
254: return copyout(&ss, data, sizeof(ss));
255: }
256:
257: case SVR4_TIOCSETP:
258: case SVR4_TIOCSETN:
259: {
260: struct sgttyb bs;
261: struct svr4_sgttyb ss;
262:
263: if ((error = copyin(data, &ss, sizeof(ss))) != 0)
264: return error;
265:
266: svr4_sgttyb_to_bsd_sgttyb(&ss, &bs);
267: #ifdef DEBUG_SVR4
268: print_svr4_sgttyb("SVR4_TIOCSET{P,N}", &ss);
269: #endif /* DEBUG_SVR4 */
270: cmd = (cmd == SVR4_TIOCSETP) ? TIOCSETP : TIOCSETN;
271: return (*ctl)(fp, cmd, (caddr_t) &bs, p);
272: }
273:
274: case SVR4_TIOCGETC:
275: {
276: struct tchars bt;
277: struct svr4_tchars st;
278:
279: error = (*ctl)(fp, TIOCGETC, (caddr_t) &bt, p);
280: if (error)
281: return error;
282:
283: bsd_tchars_to_svr4_tchars(&bt, &st);
284: #ifdef DEBUG_SVR4
285: print_svr4_tchars("SVR4_TIOCGETC", &st);
286: #endif /* DEBUG_SVR4 */
287: return copyout(&st, data, sizeof(st));
288: }
289:
290: case SVR4_TIOCSETC:
291: {
292: struct tchars bt;
293: struct svr4_tchars st;
294:
295: if ((error = copyin(data, &st, sizeof(st))) != 0)
296: return error;
297:
298: svr4_tchars_to_bsd_tchars(&st, &bt);
299: #ifdef DEBUG_SVR4
300: print_svr4_tchars("SVR4_TIOCSETC", &st);
301: #endif /* DEBUG_SVR4 */
302: return (*ctl)(fp, TIOCSETC, (caddr_t) &bt, p);
303: }
304:
305: case SVR4_TIOCGLTC:
306: {
307: struct ltchars bl;
308: struct svr4_ltchars sl;
309:
310: error = (*ctl)(fp, TIOCGLTC, (caddr_t) &bl, p);
311: if (error)
312: return error;
313:
314: bsd_ltchars_to_svr4_ltchars(&bl, &sl);
315: #ifdef DEBUG_SVR4
316: print_svr4_ltchars("SVR4_TIOCGLTC", &sl);
317: #endif /* DEBUG_SVR4 */
318: return copyout(&sl, data, sizeof(sl));
319: }
320:
321: case SVR4_TIOCSLTC:
322: {
323: struct ltchars bl;
324: struct svr4_ltchars sl;
325:
326: if ((error = copyin(data, &sl, sizeof(sl))) != 0)
327: return error;
328:
329: svr4_ltchars_to_bsd_ltchars(&sl, &bl);
330: #ifdef DEBUG_SVR4
331: print_svr4_ltchars("SVR4_TIOCSLTC", &sl);
332: #endif /* DEBUG_SVR4 */
333: return (*ctl)(fp, TIOCSLTC, (caddr_t) &bl, p);
334: }
335:
336: case SVR4_TIOCLGET:
337: {
338: int flags;
339: if ((error = (*ctl)(fp, cmd, (caddr_t) &flags, p)) !=
340: 0)
341: return error;
342: DPRINTF(("SVR4_TIOCLGET %o\n", flags));
343: return copyout(&flags, data, sizeof(flags));
344: }
345:
346: case SVR4_TIOCLSET:
347: case SVR4_TIOCLBIS:
348: case SVR4_TIOCLBIC:
349: {
350: int flags;
351:
352: if ((error = copyin(data, &flags, sizeof(flags))) != 0)
353: return error;
354:
355: switch (cmd) {
356: case SVR4_TIOCLSET:
357: cmd = TIOCLSET;
358: break;
359: case SVR4_TIOCLBIS:
360: cmd = TIOCLBIS;
361: break;
362: case SVR4_TIOCLBIC:
363: cmd = TIOCLBIC;
364: break;
365: }
366:
367: DPRINTF(("SVR4_TIOCL{SET,BIS,BIC} %o\n", flags));
368: return (*ctl)(fp, cmd, (caddr_t) &flags, p);
369: }
370:
371: default:
372: DPRINTF(("Unknown svr4 ttold %lx\n", cmd));
373: return 0; /* ENOSYS really */
374: }
375: }