Annotation of sys/compat/svr4/svr4_termios.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: svr4_termios.c,v 1.12 2002/03/14 01:26:51 millert Exp $ */
2: /* $NetBSD: svr4_termios.c,v 1.9 1996/04/11 12:53:48 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_ioctl.h>
50: #include <compat/svr4/svr4_syscallargs.h>
51: #include <compat/svr4/svr4_stropts.h>
52: #include <compat/svr4/svr4_termios.h>
53:
54: #define SVR4_OXTABS SVR4_XTABS /* XXX */
55:
56: #ifndef __CONCAT3
57: # if __STDC__
58: # define __CONCAT3(a,b,c) a ## b ## c
59: # else
60: # define __CONCAT3(a,b,c) a/**/b/**/c
61: # endif
62: #endif
63:
64: u_long bsd_to_svr4_speed(u_long, u_long);
65: u_long svr4_to_bsd_speed(u_long, u_long);
66: void svr4_to_bsd_termios(const struct svr4_termios *, struct termios *,
67: int);
68: void bsd_to_svr4_termios(const struct termios *, struct svr4_termios *);
69: void svr4_termio_to_termios(const struct svr4_termio *,
70: struct svr4_termios *);
71: void svr4_termios_to_termio(const struct svr4_termios *,
72: struct svr4_termio *);
73: #ifdef DEBUG_SVR4
74: void print_svr4_termios(const struct svr4_termios *);
75: void print_bsd_termios(const struct termios *);
76: #endif /* DEBUG_SVR4 */
77:
78: #define undefined_char(a,b) /**/
79: #define undefined_flag1(f,a,b) /**/
80: #define undefined_flag2(f,a,b,c1,t1,c2,t2) /**/
81: #define undefined_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) /**/
82:
83: #define svr4_to_bsd_char(a,b) \
84: if (new || __CONCAT3(SVR4_,a,b) < SVR4_NCC) { \
85: if (st->c_cc[__CONCAT3(SVR4_,a,b)] == SVR4_POSIX_VDISABLE) \
86: bt->c_cc[__CONCAT(a,b)] = _POSIX_VDISABLE; \
87: else \
88: bt->c_cc[__CONCAT(a,b)] = \
89: st->c_cc[__CONCAT3(SVR4_,a,b)]; \
90: }
91:
92: #define svr4_to_bsd_flag1(f,a,b) \
93: if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
94: if (st->f & __CONCAT3(SVR4_,a,b)) \
95: bt->f |= __CONCAT(a,b); \
96: else \
97: bt->f &= ~__CONCAT(a,b); \
98: }
99:
100: #define svr4_to_bsd_flag2(f,a,b,c1,t1,c2,t2) \
101: if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
102: bt->f &= ~__CONCAT(a,b); \
103: switch (st->f & __CONCAT3(SVR4_,a,b)) { \
104: case __CONCAT3(SVR4_,c1,t1): bt->f |= __CONCAT(c1,t1); break; \
105: case __CONCAT3(SVR4_,c2,t2): bt->f |= __CONCAT(c2,t2); break; \
106: } \
107: }
108:
109: #define svr4_to_bsd_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) \
110: if (new || __CONCAT3(SVR4_,a,b) < 0200000) { \
111: bt->f &= ~__CONCAT(a,b); \
112: switch (st->f & __CONCAT3(SVR4_,a,b)) { \
113: case __CONCAT3(SVR4_,c1,t1): bt->f |= __CONCAT(c1,t1); break; \
114: case __CONCAT3(SVR4_,c2,t2): bt->f |= __CONCAT(c2,t2); break; \
115: case __CONCAT3(SVR4_,c3,t3): bt->f |= __CONCAT(c3,t3); break; \
116: case __CONCAT3(SVR4_,c4,t4): bt->f |= __CONCAT(c4,t4); break; \
117: } \
118: }
119:
120:
121: #define bsd_to_svr4_char(a,b) \
122: if (bt->c_cc[__CONCAT(a,b)] == _POSIX_VDISABLE) \
123: st->c_cc[__CONCAT3(SVR4_,a,b)] = SVR4_POSIX_VDISABLE; \
124: else \
125: st->c_cc[__CONCAT3(SVR4_,a,b)] = bt->c_cc[__CONCAT(a,b)]
126:
127: #define bsd_to_svr4_flag1(f,a,b) \
128: if (bt->f & __CONCAT(a,b)) \
129: st->f |= __CONCAT3(SVR4_,a,b); \
130: else \
131: st->f &= ~__CONCAT3(SVR4_,a,b)
132:
133: #define bsd_to_svr4_flag2(f,a,b,c1,t1,c2,t2) \
134: st->f &= ~__CONCAT3(SVR4_,a,b); \
135: switch (bt->f & __CONCAT(a,b)) { \
136: case __CONCAT(c1,t1): st->f |= __CONCAT3(SVR4_,c1,t1); break; \
137: case __CONCAT(c2,t2): st->f |= __CONCAT3(SVR4_,c2,t2); break; \
138: }
139:
140: #define bsd_to_svr4_flag4(f,a,b,c1,t1,c2,t2,c3,t3,c4,t4) \
141: st->f &= ~__CONCAT3(SVR4_,a,b); \
142: switch (bt->f & __CONCAT(a,b)) { \
143: case __CONCAT(c1,t1): st->f |= __CONCAT3(SVR4_,c1,t1); break; \
144: case __CONCAT(c2,t2): st->f |= __CONCAT3(SVR4_,c2,t2); break; \
145: case __CONCAT(c3,t3): st->f |= __CONCAT3(SVR4_,c3,t3); break; \
146: case __CONCAT(c4,t4): st->f |= __CONCAT3(SVR4_,c4,t4); break; \
147: }
148:
149: #ifdef DEBUG_SVR4
150: void
151: print_svr4_termios(st)
152: const struct svr4_termios *st;
153: {
154: int i;
155: uprintf("SVR4\niflag=%lo oflag=%lo cflag=%lo lflag=%lo\n",
156: st->c_iflag, st->c_oflag, st->c_cflag, st->c_lflag);
157: uprintf("cc: ");
158: for (i = 0; i < SVR4_NCCS; i++)
159: uprintf("%o ", st->c_cc[i]);
160: uprintf("\n");
161: }
162:
163: void
164: print_bsd_termios(bt)
165: const struct termios *bt;
166: {
167: int i;
168: uprintf(
169: "BSD\niflag=%x oflag=%x cflag=%x lflag=%x ispeed=%d osped=%d\n",
170: bt->c_iflag, bt->c_oflag, bt->c_cflag, bt->c_lflag, bt->c_ispeed,
171: bt->c_ospeed);
172: uprintf("cc: ");
173: for (i = 0; i < NCCS; i++)
174: uprintf("%o ", bt->c_cc[i]);
175: uprintf("\n");
176: }
177: #endif /* DEBUG_SVR4 */
178:
179: u_long
180: bsd_to_svr4_speed(sp, mask)
181: u_long sp;
182: u_long mask;
183: {
184: switch (sp) {
185: #undef getval
186: #define getval(a,b) case __CONCAT(a,b): sp = __CONCAT3(SVR4_,a,b); break
187: getval(B,0);
188: getval(B,50);
189: getval(B,75);
190: getval(B,110);
191: getval(B,134);
192: getval(B,150);
193: getval(B,200);
194: getval(B,300);
195: getval(B,600);
196: getval(B,1200);
197: getval(B,1800);
198: getval(B,2400);
199: getval(B,4800);
200: getval(B,9600);
201: getval(B,19200);
202: getval(B,38400);
203: #if 0
204: /* XXX These don't fit in CBAUD */
205: getval(B,57600);
206: getval(B,115200);
207: #endif
208: default: sp = SVR4_B9600; /* XXX */
209: }
210:
211: while ((mask & 1) == 0) {
212: mask >>= 1;
213: sp <<= 1;
214: }
215:
216: return (sp);
217: }
218:
219: u_long
220: svr4_to_bsd_speed(sp, mask)
221: u_long sp;
222: u_long mask;
223: {
224: while ((mask & 1) == 0) {
225: mask >>= 1;
226: sp >>= 1;
227: }
228:
229: switch (sp & mask) {
230: #undef getval
231: #define getval(a,b) case __CONCAT3(SVR4_,a,b): return (__CONCAT(a,b))
232: getval(B,0);
233: getval(B,50);
234: getval(B,75);
235: getval(B,110);
236: getval(B,134);
237: getval(B,150);
238: getval(B,200);
239: getval(B,300);
240: getval(B,600);
241: getval(B,1200);
242: getval(B,1800);
243: getval(B,2400);
244: getval(B,4800);
245: getval(B,9600);
246: getval(B,19200);
247: getval(B,38400);
248: #if 0
249: /* XXX These don't fit in CBAUD */
250: getval(B,57600);
251: getval(B,115200);
252: #endif
253: default: return (B9600); /* XXX */
254: }
255: }
256:
257: void
258: svr4_to_bsd_termios(st, bt, new)
259: const struct svr4_termios *st;
260: struct termios *bt;
261: int new;
262: {
263: /* control characters */
264: svr4_to_bsd_char(V,INTR);
265: svr4_to_bsd_char(V,QUIT);
266: svr4_to_bsd_char(V,ERASE);
267: svr4_to_bsd_char(V,KILL);
268: if (st->c_lflag & ICANON) {
269: svr4_to_bsd_char(V,EOF);
270: svr4_to_bsd_char(V,EOL);
271: } else {
272: /*
273: * These are not chars so _POSIX_DISABLE values should not be
274: * special cased.
275: */
276: bt->c_cc[VMIN] = st->c_cc[SVR4_VMIN];
277: bt->c_cc[VTIME] = st->c_cc[SVR4_VTIME];
278: }
279: svr4_to_bsd_char(V,EOF);
280: svr4_to_bsd_char(V,EOL);
281: svr4_to_bsd_char(V,EOL2);
282: undefined_char(V,SWTCH);
283: svr4_to_bsd_char(V,START);
284: svr4_to_bsd_char(V,STOP);
285: svr4_to_bsd_char(V,SUSP);
286: svr4_to_bsd_char(V,DSUSP);
287: svr4_to_bsd_char(V,REPRINT);
288: svr4_to_bsd_char(V,DISCARD);
289: svr4_to_bsd_char(V,WERASE);
290: svr4_to_bsd_char(V,LNEXT);
291:
292: /* Input modes */
293: svr4_to_bsd_flag1(c_iflag,I,GNBRK);
294: svr4_to_bsd_flag1(c_iflag,B,RKINT);
295: svr4_to_bsd_flag1(c_iflag,I,GNPAR);
296: svr4_to_bsd_flag1(c_iflag,P,ARMRK);
297: svr4_to_bsd_flag1(c_iflag,I,NPCK);
298: svr4_to_bsd_flag1(c_iflag,I,STRIP);
299: svr4_to_bsd_flag1(c_iflag,I,NLCR);
300: svr4_to_bsd_flag1(c_iflag,I,GNCR);
301: svr4_to_bsd_flag1(c_iflag,I,CRNL);
302: undefined_flag1(c_iflag,I,UCLC);
303: svr4_to_bsd_flag1(c_iflag,I,XON);
304: svr4_to_bsd_flag1(c_iflag,I,XANY);
305: svr4_to_bsd_flag1(c_iflag,I,XOFF);
306: svr4_to_bsd_flag1(c_iflag,I,MAXBEL);
307: undefined_flag1(c_iflag,D,OSMODE);
308:
309: /* Output modes */
310: svr4_to_bsd_flag1(c_oflag,O,POST);
311: undefined_flag1(c_oflag,O,LCUC);
312: svr4_to_bsd_flag1(c_oflag,O,NLCR);
313: undefined_flag1(c_oflag,O,CRNL);
314: undefined_flag1(c_oflag,O,NOCR);
315: undefined_flag1(c_oflag,O,NLRET);
316: undefined_flag1(c_oflag,O,FILL);
317: undefined_flag1(c_oflag,O,FDEL);
318: undefined_flag2(c_oflag,N,LDLY,N,L0,N,L1);
319: undefined_flag4(c_oflag,C,RDLY,C,R0,C,R1,C,R2,C,R3);
320: undefined_flag4(c_oflag,T,ABDLY,T,AB0,T,AB1,T,AB2,T,AB3);
321: /*
322: * XXX Note, we cannot use svr4_to_bsd_flag1 here because the SVR4
323: * field is a two bit value where identity is important, i.e. any bit
324: * set in that field is *not* enough. Someday we might to wish to
325: * support the other values of this bitfield, but not now...
326: */
327: if ((st->c_oflag & SVR4_XTABS) == SVR4_XTABS)
328: bt->c_oflag |= OXTABS;
329: else
330: bt->c_oflag &= ~OXTABS;
331: undefined_flag2(c_oflag,B,SDLY,B,S0,B,S1);
332: undefined_flag2(c_oflag,V,TDLY,V,T0,V,T1);
333: undefined_flag2(c_oflag,F,FDLY,F,F0,F,F1);
334: undefined_flag1(c_oflag,P,AGEOUT);
335: undefined_flag1(c_oflag,W,RAP);
336:
337: /* Control modes */
338: bt->c_ospeed = svr4_to_bsd_speed(st->c_cflag, SVR4_CBAUD);
339: svr4_to_bsd_flag4(c_cflag,C,SIZE,C,S5,C,S6,C,S7,C,S8)
340: svr4_to_bsd_flag1(c_cflag,C,STOPB);
341: svr4_to_bsd_flag1(c_cflag,C,READ);
342: svr4_to_bsd_flag1(c_cflag,P,ARENB);
343: svr4_to_bsd_flag1(c_cflag,P,ARODD);
344: svr4_to_bsd_flag1(c_cflag,H,UPCL);
345: svr4_to_bsd_flag1(c_cflag,C,LOCAL);
346: undefined_flag1(c_cflag,R,CV1EN);
347: undefined_flag1(c_cflag,X,MT1EN);
348: undefined_flag1(c_cflag,L,OBLK);
349: undefined_flag1(c_cflag,X,CLUDE);
350: bt->c_ispeed = svr4_to_bsd_speed(st->c_cflag, SVR4_CIBAUD);
351: undefined_flag1(c_cflag,P,AREXT);
352:
353: /* line discipline modes */
354: svr4_to_bsd_flag1(c_lflag,I,SIG);
355: svr4_to_bsd_flag1(c_lflag,I,CANON);
356: undefined_flag1(c_lflag,X,CASE);
357: svr4_to_bsd_flag1(c_lflag,E,CHO);
358: svr4_to_bsd_flag1(c_lflag,E,CHOE);
359: svr4_to_bsd_flag1(c_lflag,E,CHOK);
360: svr4_to_bsd_flag1(c_lflag,E,CHONL);
361: svr4_to_bsd_flag1(c_lflag,N,OFLSH);
362: svr4_to_bsd_flag1(c_lflag,T,OSTOP);
363: svr4_to_bsd_flag1(c_lflag,E,CHOCTL);
364: svr4_to_bsd_flag1(c_lflag,E,CHOPRT);
365: svr4_to_bsd_flag1(c_lflag,E,CHOKE);
366: undefined_flag1(c_lflag,D,EFECHO);
367: svr4_to_bsd_flag1(c_lflag,F,LUSHO);
368: svr4_to_bsd_flag1(c_lflag,P,ENDIN);
369: svr4_to_bsd_flag1(c_lflag,I,EXTEN);
370: }
371:
372: void
373: bsd_to_svr4_termios(bt, st)
374: const struct termios *bt;
375: struct svr4_termios *st;
376: {
377: /* control characters */
378: bsd_to_svr4_char(V,INTR);
379: bsd_to_svr4_char(V,QUIT);
380: bsd_to_svr4_char(V,ERASE);
381: bsd_to_svr4_char(V,KILL);
382: if (bt->c_lflag & ICANON) {
383: bsd_to_svr4_char(V,EOF);
384: bsd_to_svr4_char(V,EOL);
385: } else {
386: /*
387: * These are not chars so _POSIX_DISABLE values should not be
388: * special cased.
389: */
390: st->c_cc[SVR4_VMIN] = bt->c_cc[VMIN];
391: st->c_cc[SVR4_VTIME] = bt->c_cc[VTIME];
392: }
393: bsd_to_svr4_char(V,EOL2);
394: undefined_char(V,SWTCH);
395: bsd_to_svr4_char(V,START);
396: bsd_to_svr4_char(V,STOP);
397: bsd_to_svr4_char(V,SUSP);
398: bsd_to_svr4_char(V,DSUSP);
399: bsd_to_svr4_char(V,REPRINT);
400: bsd_to_svr4_char(V,DISCARD);
401: bsd_to_svr4_char(V,WERASE);
402: bsd_to_svr4_char(V,LNEXT);
403:
404: /* Input modes */
405: bsd_to_svr4_flag1(c_iflag,I,GNBRK);
406: bsd_to_svr4_flag1(c_iflag,B,RKINT);
407: bsd_to_svr4_flag1(c_iflag,I,GNPAR);
408: bsd_to_svr4_flag1(c_iflag,P,ARMRK);
409: bsd_to_svr4_flag1(c_iflag,I,NPCK);
410: bsd_to_svr4_flag1(c_iflag,I,STRIP);
411: bsd_to_svr4_flag1(c_iflag,I,NLCR);
412: bsd_to_svr4_flag1(c_iflag,I,GNCR);
413: bsd_to_svr4_flag1(c_iflag,I,CRNL);
414: undefined_flag1(c_iflag,I,UCLC);
415: bsd_to_svr4_flag1(c_iflag,I,XON);
416: bsd_to_svr4_flag1(c_iflag,I,XANY);
417: bsd_to_svr4_flag1(c_iflag,I,XOFF);
418: bsd_to_svr4_flag1(c_iflag,I,MAXBEL);
419: undefined_flag1(c_iflag,D,OSMODE);
420:
421: /* Output modes */
422: bsd_to_svr4_flag1(c_oflag,O,POST);
423: undefined_flag1(c_oflag,O,LCUC);
424: bsd_to_svr4_flag1(c_oflag,O,NLCR);
425: undefined_flag1(c_oflag,O,CRNL);
426: undefined_flag1(c_oflag,O,NOCR);
427: undefined_flag1(c_oflag,O,NLRET);
428: undefined_flag1(c_oflag,O,FILL);
429: undefined_flag1(c_oflag,O,FDEL);
430: undefined_flag2(c_oflag,N,LDLY,N,L0,N,L1);
431: undefined_flag4(c_oflag,C,RDLY,C,R0,C,R1,C,R2,C,R3);
432: undefined_flag4(c_oflag,T,ABDLY,T,AB0,T,AB1,T,AB2,T,AB3);
433: /*
434: * XXX This isn't what it seem to be, a one bit flag... It's actually
435: * a two bit value in SVR4 with composite semantics, where we only
436: * support one of them. Be careful if you change this...
437: */
438: bsd_to_svr4_flag1(c_oflag,OX,TABS);
439: undefined_flag2(c_oflag,B,SDLY,B,S0,B,S1);
440: undefined_flag2(c_oflag,V,TDLY,V,T0,V,T1);
441: undefined_flag2(c_oflag,F,FDLY,F,F0,F,F1);
442: undefined_flag1(c_oflag,P,AGEOUT);
443: undefined_flag1(c_oflag,W,RAP);
444:
445: /* Control modes */
446: st->c_cflag &= ~SVR4_CBAUD;
447: st->c_cflag |= bsd_to_svr4_speed(bt->c_ospeed, SVR4_CBAUD);
448: bsd_to_svr4_flag4(c_cflag,C,SIZE,C,S5,C,S6,C,S7,C,S8)
449: bsd_to_svr4_flag1(c_cflag,C,STOPB);
450: bsd_to_svr4_flag1(c_cflag,C,READ);
451: bsd_to_svr4_flag1(c_cflag,P,ARENB);
452: bsd_to_svr4_flag1(c_cflag,P,ARODD);
453: bsd_to_svr4_flag1(c_cflag,H,UPCL);
454: bsd_to_svr4_flag1(c_cflag,C,LOCAL);
455: undefined_flag1(c_cflag,R,CV1EN);
456: undefined_flag1(c_cflag,X,MT1EN);
457: undefined_flag1(c_cflag,L,OBLK);
458: undefined_flag1(c_cflag,X,CLUDE);
459: st->c_cflag &= ~SVR4_CIBAUD;
460: st->c_cflag |= bsd_to_svr4_speed(bt->c_ispeed, SVR4_CIBAUD);
461:
462: undefined_flag1(c_oflag,P,AREXT);
463:
464: /* line discipline modes */
465: bsd_to_svr4_flag1(c_lflag,I,SIG);
466: bsd_to_svr4_flag1(c_lflag,I,CANON);
467: undefined_flag1(c_lflag,X,CASE);
468: bsd_to_svr4_flag1(c_lflag,E,CHO);
469: bsd_to_svr4_flag1(c_lflag,E,CHOE);
470: bsd_to_svr4_flag1(c_lflag,E,CHOK);
471: bsd_to_svr4_flag1(c_lflag,E,CHONL);
472: bsd_to_svr4_flag1(c_lflag,N,OFLSH);
473: bsd_to_svr4_flag1(c_lflag,T,OSTOP);
474: bsd_to_svr4_flag1(c_lflag,E,CHOCTL);
475: bsd_to_svr4_flag1(c_lflag,E,CHOPRT);
476: bsd_to_svr4_flag1(c_lflag,E,CHOKE);
477: undefined_flag1(c_lflag,D,EFECHO);
478: bsd_to_svr4_flag1(c_lflag,F,LUSHO);
479: bsd_to_svr4_flag1(c_lflag,P,ENDIN);
480: bsd_to_svr4_flag1(c_lflag,I,EXTEN);
481: }
482:
483: void
484: svr4_termio_to_termios(t, ts)
485: const struct svr4_termio *t;
486: struct svr4_termios *ts;
487: {
488: int i;
489:
490: ts->c_iflag = (svr4_tcflag_t)t->c_iflag;
491: ts->c_oflag = (svr4_tcflag_t)t->c_oflag;
492: ts->c_cflag = (svr4_tcflag_t)t->c_cflag & ~SVR4_CIBAUD;
493: /* XXX because SVR4_CIBAUD == SVR4_CBAUD << 16 we can do: */
494: ts->c_cflag |= (ts->c_cflag & SVR4_CBAUD) << 16;
495: ts->c_lflag = (svr4_tcflag_t)t->c_lflag;
496:
497: for (i = 0; i < SVR4_NCC; i++)
498: ts->c_cc[i] = (svr4_cc_t)t->c_cc[i];
499: }
500:
501: void
502: svr4_termios_to_termio(ts, t)
503: const struct svr4_termios *ts;
504: struct svr4_termio *t;
505: {
506: int i;
507:
508: t->c_iflag = (u_short)ts->c_iflag;
509: t->c_oflag = (u_short)ts->c_oflag;
510: t->c_cflag = (u_short)ts->c_cflag;
511: t->c_lflag = (u_short)ts->c_lflag;
512: t->c_line = 0; /* XXX */
513:
514: for (i = 0; i < SVR4_NCC; i++)
515: t->c_cc[i] = (u_char)ts->c_cc[i];
516: }
517:
518: int
519: svr4_term_ioctl(fp, p, retval, fd, cmd, data)
520: struct file *fp;
521: struct proc *p;
522: register_t *retval;
523: int fd;
524: u_long cmd;
525: caddr_t data;
526: {
527: struct termios bt;
528: struct svr4_termios st;
529: struct svr4_termio t;
530: int error, new;
531: int (*ctl)(struct file *, u_long, caddr_t, struct proc *) =
532: fp->f_ops->fo_ioctl;
533:
534: *retval = 0;
535:
536: switch (cmd) {
537: case SVR4_TCGETA:
538: case SVR4_TCGETS:
539: if ((error = (*ctl)(fp, TIOCGETA, (caddr_t)&bt, p)) != 0)
540: return (error);
541:
542: bzero(&st,sizeof(st));
543: bsd_to_svr4_termios(&bt, &st);
544:
545: DPRINTF(("ioctl(TCGET%c);\n", cmd == SVR4_TCGETA ? 'A' : 'S'));
546: #ifdef DEBUG_SVR4
547: print_bsd_termios(&bt);
548: print_svr4_termios(&st);
549: #endif /* DEBUG_SVR4 */
550:
551: if (cmd == SVR4_TCGETA) {
552: svr4_termios_to_termio(&st, &t);
553: return (copyout(&t, data, sizeof(t)));
554: }
555: else {
556: return (copyout(&st, data, sizeof(st)));
557: }
558:
559: case SVR4_TCSETA:
560: case SVR4_TCSETS:
561: case SVR4_TCSETAW:
562: case SVR4_TCSETSW:
563: case SVR4_TCSETAF:
564: case SVR4_TCSETSF:
565: /* get full BSD termios so we don't lose information */
566: if ((error = (*ctl)(fp, TIOCGETA, (caddr_t) &bt, p)) != 0)
567: return (error);
568:
569: switch (cmd) {
570: case SVR4_TCSETS:
571: case SVR4_TCSETSW:
572: case SVR4_TCSETSF:
573: if ((error = copyin(data, &st, sizeof(st))) != 0)
574: return (error);
575: new = 1;
576: break;
577:
578: case SVR4_TCSETA:
579: case SVR4_TCSETAW:
580: case SVR4_TCSETAF:
581: if ((error = copyin(data, &t, sizeof(t))) != 0)
582: return (error);
583:
584: bsd_to_svr4_termios(&bt, &st);
585: svr4_termio_to_termios(&t, &st);
586: new = 0;
587: break;
588:
589: default:
590: return (EINVAL);
591: }
592:
593: svr4_to_bsd_termios(&st, &bt, new);
594:
595: switch (cmd) {
596: case SVR4_TCSETA:
597: case SVR4_TCSETS:
598: DPRINTF(("ioctl(TCSET[A|S]);\n"));
599: cmd = TIOCSETA;
600: break;
601: case SVR4_TCSETAW:
602: case SVR4_TCSETSW:
603: DPRINTF(("ioctl(TCSET[A|S]W);\n"));
604: cmd = TIOCSETAW;
605: break;
606: case SVR4_TCSETAF:
607: case SVR4_TCSETSF:
608: DPRINTF(("ioctl(TCSET[A|S]F);\n"));
609: cmd = TIOCSETAF;
610: break;
611: }
612:
613: #ifdef DEBUG_SVR4
614: print_bsd_termios(&bt);
615: print_svr4_termios(&st);
616: #endif /* DEBUG_SVR4 */
617:
618: return ((*ctl)(fp, cmd, (caddr_t) &bt, p));
619:
620: case SVR4_TIOCGWINSZ:
621: {
622: struct svr4_winsize ws;
623:
624: error = (*ctl)(fp, TIOCGWINSZ, (caddr_t)&ws, p);
625: if (error)
626: return (error);
627: return (copyout(&ws, data, sizeof(ws)));
628: }
629:
630: case SVR4_TIOCSWINSZ:
631: {
632: struct svr4_winsize ws;
633:
634: if ((error = copyin(data, &ws, sizeof(ws))) != 0)
635: return (error);
636: return ((*ctl)(fp, TIOCSWINSZ, (caddr_t) &ws, p));
637: }
638:
639: default:
640: return (svr4_stream_ti_ioctl(fp, p, retval, fd, cmd, data));
641: }
642: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to svr4_termios.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4