1 /*-
2 * Copyright (c) 1998 Mark Newton
3 * Copyright (c) 1994 Christos Zoulas
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. 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/cdefs.h>
30 __FBSDID("$FreeBSD: src/sys/compat/svr4/svr4_ttold.c,v 1.13.2.1 2005/01/30 00:59:20 imp Exp $");
31
32 #ifndef BURN_BRIDGES
33
34 #include <sys/param.h>
35 #include <sys/proc.h>
36 #include <sys/systm.h>
37 #include <sys/file.h>
38 #include <sys/filedesc.h>
39 #include <sys/ioctl_compat.h>
40 #include <sys/termios.h>
41
42 #include <compat/svr4/svr4.h>
43 #include <compat/svr4/svr4_util.h>
44 #include <compat/svr4/svr4_ttold.h>
45 #include <compat/svr4/svr4_ioctl.h>
46
47
48 static void svr4_tchars_to_bsd_tchars(const struct svr4_tchars *st,
49 struct tchars *bt);
50 static void bsd_tchars_to_svr4_tchars(const struct tchars *bt,
51 struct svr4_tchars *st);
52 static void svr4_sgttyb_to_bsd_sgttyb(const struct svr4_sgttyb *ss,
53 struct sgttyb *bs);
54 static void bsd_sgttyb_to_svr4_sgttyb(const struct sgttyb *bs,
55 struct svr4_sgttyb *ss);
56 static void svr4_ltchars_to_bsd_ltchars(const struct svr4_ltchars *sl,
57 struct ltchars *bl);
58 static void bsd_ltchars_to_svr4_ltchars(const struct ltchars *bl,
59 struct svr4_ltchars *sl);
60
61 #ifdef DEBUG_SVR4
62 static void print_svr4_sgttyb(const char *, struct svr4_sgttyb *);
63 static void print_svr4_tchars(const char *, struct svr4_tchars *);
64 static void print_svr4_ltchars(const char *, struct svr4_ltchars *);
65
66 static void
67 print_svr4_sgttyb(str, ss)
68 const char *str;
69 struct svr4_sgttyb *ss;
70 {
71
72 uprintf("%s\nispeed=%o ospeed=%o ", str, ss->sg_ispeed, ss->sg_ospeed);
73 uprintf("erase=%o kill=%o flags=%o\n", ss->sg_erase, ss->sg_kill,
74 ss->sg_flags);
75 }
76
77 static void
78 print_svr4_tchars(str, st)
79 const char *str;
80 struct svr4_tchars *st;
81 {
82 uprintf("%s\nintrc=%o quitc=%o ", str, st->t_intrc, st->t_quitc);
83 uprintf("startc=%o stopc=%o eofc=%o brkc=%o\n", st->t_startc,
84 st->t_stopc, st->t_eofc, st->t_brkc);
85 }
86
87 static void
88 print_svr4_ltchars(str, sl)
89 const char *str;
90 struct svr4_ltchars *sl;
91 {
92 uprintf("%s\nsuspc=%o dsuspc=%o ", str, sl->t_suspc, sl->t_dsuspc);
93 uprintf("rprntc=%o flushc=%o werasc=%o lnextc=%o\n", sl->t_rprntc,
94 sl->t_flushc, sl->t_werasc, sl->t_lnextc);
95 }
96 #endif /* DEBUG_SVR4 */
97
98 static void
99 svr4_tchars_to_bsd_tchars(st, bt)
100 const struct svr4_tchars *st;
101 struct tchars *bt;
102 {
103 bt->t_intrc = st->t_intrc;
104 bt->t_quitc = st->t_quitc;
105 bt->t_startc = st->t_startc;
106 bt->t_stopc = st->t_stopc;
107 bt->t_eofc = st->t_eofc;
108 bt->t_brkc = st->t_brkc;
109 }
110
111
112 static void
113 bsd_tchars_to_svr4_tchars(bt, st)
114 const struct tchars *bt;
115 struct svr4_tchars *st;
116 {
117 st->t_intrc = bt->t_intrc;
118 st->t_quitc = bt->t_quitc;
119 st->t_startc = bt->t_startc;
120 st->t_stopc = bt->t_stopc;
121 st->t_eofc = bt->t_eofc;
122 st->t_brkc = bt->t_brkc;
123 }
124
125
126 static void
127 svr4_sgttyb_to_bsd_sgttyb(ss, bs)
128 const struct svr4_sgttyb *ss;
129 struct sgttyb *bs;
130 {
131 bs->sg_ispeed = ss->sg_ispeed;
132 bs->sg_ospeed = ss->sg_ospeed;
133 bs->sg_erase = ss->sg_erase;
134 bs->sg_kill = ss->sg_kill;
135 bs->sg_flags = ss->sg_flags;
136 };
137
138
139 static void
140 bsd_sgttyb_to_svr4_sgttyb(bs, ss)
141 const struct sgttyb *bs;
142 struct svr4_sgttyb *ss;
143 {
144 ss->sg_ispeed = bs->sg_ispeed;
145 ss->sg_ospeed = bs->sg_ospeed;
146 ss->sg_erase = bs->sg_erase;
147 ss->sg_kill = bs->sg_kill;
148 ss->sg_flags = bs->sg_flags;
149 }
150
151
152 static void
153 svr4_ltchars_to_bsd_ltchars(sl, bl)
154 const struct svr4_ltchars *sl;
155 struct ltchars *bl;
156 {
157 bl->t_suspc = sl->t_suspc;
158 bl->t_dsuspc = sl->t_dsuspc;
159 bl->t_rprntc = sl->t_rprntc;
160 bl->t_flushc = sl->t_flushc;
161 bl->t_werasc = sl->t_werasc;
162 bl->t_lnextc = sl->t_lnextc;
163 }
164
165
166 static void
167 bsd_ltchars_to_svr4_ltchars(bl, sl)
168 const struct ltchars *bl;
169 struct svr4_ltchars *sl;
170 {
171 sl->t_suspc = bl->t_suspc;
172 sl->t_dsuspc = bl->t_dsuspc;
173 sl->t_rprntc = bl->t_rprntc;
174 sl->t_flushc = bl->t_flushc;
175 sl->t_werasc = bl->t_werasc;
176 sl->t_lnextc = bl->t_lnextc;
177 }
178
179
180 int
181 svr4_ttold_ioctl(fp, td, retval, fd, cmd, data)
182 struct file *fp;
183 struct thread *td;
184 register_t *retval;
185 int fd;
186 u_long cmd;
187 caddr_t data;
188 {
189 int error;
190
191 *retval = 0;
192
193 switch (cmd) {
194 case SVR4_TIOCGPGRP:
195 {
196 pid_t pid;
197
198 if ((error = fo_ioctl(fp, TIOCGPGRP, (caddr_t) &pid,
199 td->td_ucred, td)) != 0)
200 return error;
201
202 DPRINTF(("TIOCGPGRP %d\n", pid));
203
204 if ((error = copyout(&pid, data, sizeof(pid))) != 0)
205 return error;
206
207 }
208
209 case SVR4_TIOCSPGRP:
210 {
211 pid_t pid;
212
213 if ((error = copyin(data, &pid, sizeof(pid))) != 0)
214 return error;
215
216 DPRINTF(("TIOCSPGRP %d\n", pid));
217
218 return fo_ioctl(fp, TIOCSPGRP, (caddr_t) &pid,
219 td->td_ucred, td);
220 }
221
222 case SVR4_TIOCGSID:
223 {
224 #if defined(TIOCGSID)
225 pid_t pid;
226 if ((error = fo_ioctl(fp, TIOCGSID, (caddr_t) &pid,
227 td->td_ucred, td)) != 0)
228 return error;
229
230 DPRINTF(("TIOCGSID %d\n", pid));
231
232 return copyout(&pid, data, sizeof(pid));
233 #else
234 uprintf("ioctl(TIOCGSID) for pid %d unsupported\n", td->td_proc->p_pid);
235 return EINVAL;
236 #endif
237 }
238
239 case SVR4_TIOCGETP:
240 {
241 struct sgttyb bs;
242 struct svr4_sgttyb ss;
243
244 error = fo_ioctl(fp, TIOCGETP, (caddr_t) &bs,
245 td->td_ucred, td);
246 if (error)
247 return error;
248
249 bsd_sgttyb_to_svr4_sgttyb(&bs, &ss);
250 #ifdef DEBUG_SVR4
251 print_svr4_sgttyb("SVR4_TIOCGETP", &ss);
252 #endif /* DEBUG_SVR4 */
253 return copyout(&ss, data, sizeof(ss));
254 }
255
256 case SVR4_TIOCSETP:
257 case SVR4_TIOCSETN:
258 {
259 struct sgttyb bs;
260 struct svr4_sgttyb ss;
261
262 if ((error = copyin(data, &ss, sizeof(ss))) != 0)
263 return error;
264
265 svr4_sgttyb_to_bsd_sgttyb(&ss, &bs);
266 #ifdef DEBUG_SVR4
267 print_svr4_sgttyb("SVR4_TIOCSET{P,N}", &ss);
268 #endif /* DEBUG_SVR4 */
269 cmd = (cmd == SVR4_TIOCSETP) ? TIOCSETP : TIOCSETN;
270 return fo_ioctl(fp, cmd, (caddr_t) &bs,
271 td->td_ucred, td);
272 }
273
274 case SVR4_TIOCGETC:
275 {
276 struct tchars bt;
277 struct svr4_tchars st;
278
279 error = fo_ioctl(fp, TIOCGETC, (caddr_t) &bt,
280 td->td_ucred, td);
281 if (error)
282 return error;
283
284 bsd_tchars_to_svr4_tchars(&bt, &st);
285 #ifdef DEBUG_SVR4
286 print_svr4_tchars("SVR4_TIOCGETC", &st);
287 #endif /* DEBUG_SVR4 */
288 return copyout(&st, data, sizeof(st));
289 }
290
291 case SVR4_TIOCSETC:
292 {
293 struct tchars bt;
294 struct svr4_tchars st;
295
296 if ((error = copyin(data, &st, sizeof(st))) != 0)
297 return error;
298
299 svr4_tchars_to_bsd_tchars(&st, &bt);
300 #ifdef DEBUG_SVR4
301 print_svr4_tchars("SVR4_TIOCSETC", &st);
302 #endif /* DEBUG_SVR4 */
303 return fo_ioctl(fp, TIOCSETC, (caddr_t) &bt,
304 td->td_ucred, td);
305 }
306
307 case SVR4_TIOCGLTC:
308 {
309 struct ltchars bl;
310 struct svr4_ltchars sl;
311
312 error = fo_ioctl(fp, TIOCGLTC, (caddr_t) &bl,
313 td->td_ucred, td);
314 if (error)
315 return error;
316
317 bsd_ltchars_to_svr4_ltchars(&bl, &sl);
318 #ifdef DEBUG_SVR4
319 print_svr4_ltchars("SVR4_TIOCGLTC", &sl);
320 #endif /* DEBUG_SVR4 */
321 return copyout(&sl, data, sizeof(sl));
322 }
323
324 case SVR4_TIOCSLTC:
325 {
326 struct ltchars bl;
327 struct svr4_ltchars sl;
328
329 if ((error = copyin(data, &sl, sizeof(sl))) != 0)
330 return error;
331
332 svr4_ltchars_to_bsd_ltchars(&sl, &bl);
333 #ifdef DEBUG_SVR4
334 print_svr4_ltchars("SVR4_TIOCSLTC", &sl);
335 #endif /* DEBUG_SVR4 */
336 return fo_ioctl(fp, TIOCSLTC, (caddr_t) &bl,
337 td->td_ucred, td);
338 }
339
340 case SVR4_TIOCLGET:
341 {
342 int flags;
343 if ((error = fo_ioctl(fp, TIOCLGET, (caddr_t) &flags,
344 td->td_ucred, td)) != 0)
345 return error;
346 DPRINTF(("SVR4_TIOCLGET %o\n", flags));
347 return copyout(&flags, data, sizeof(flags));
348 }
349
350 case SVR4_TIOCLSET:
351 case SVR4_TIOCLBIS:
352 case SVR4_TIOCLBIC:
353 {
354 int flags;
355
356 if ((error = copyin(data, &flags, sizeof(flags))) != 0)
357 return error;
358
359 switch (cmd) {
360 case SVR4_TIOCLSET:
361 cmd = TIOCLSET;
362 break;
363 case SVR4_TIOCLBIS:
364 cmd = TIOCLBIS;
365 break;
366 case SVR4_TIOCLBIC:
367 cmd = TIOCLBIC;
368 break;
369 }
370
371 DPRINTF(("SVR4_TIOCL{SET,BIS,BIC} %o\n", flags));
372 return fo_ioctl(fp, cmd, (caddr_t) &flags,
373 td->td_ucred, td);
374 }
375
376 default:
377 DPRINTF(("Unknown svr4 ttold %lx\n", cmd));
378 return 0; /* ENOSYS really */
379 }
380 }
381
382 #endif /* BURN_BRIDGES */
Cache object: b4c531cb35bb8761e0861c1b60a4cc73
|