This source file includes following definitions.
- print_svr4_termios
- print_bsd_termios
- bsd_to_svr4_speed
- svr4_to_bsd_speed
- svr4_to_bsd_termios
- bsd_to_svr4_termios
- svr4_termio_to_termios
- svr4_termios_to_termio
- svr4_term_ioctl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
55
56 #ifndef __CONCAT3
57 # if __STDC__
58 # define __CONCAT3(a,b,c) a ## b ## c
59 # else
60 # define __CONCAT3(a,b,c) abc
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
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
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
205 getval(B,57600);
206 getval(B,115200);
207 #endif
208 default: sp = SVR4_B9600;
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
250 getval(B,57600);
251 getval(B,115200);
252 #endif
253 default: return (B9600);
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
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
274
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
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
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
323
324
325
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
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
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
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
388
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
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
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
435
436
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
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
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
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;
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
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
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
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 }