1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1982, 1986, 1991, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33/*
34 * mapping routines for old line discipline (yuck)
35 */
36
37#include <sys/param.h>
38#include <sys/systm.h>
39#include <sys/ioctl_compat.h>
40#include <sys/tty.h>
41#include <sys/kernel.h>
42#include <sys/sysctl.h>
43
44struct speedtab {
45	int sp_speed;			/* Speed. */
46	int sp_code;			/* Code. */
47};
48
49static int ttcompatgetflags(struct tty *tp);
50static void ttcompatsetflags(struct tty *tp, struct termios *t);
51static void ttcompatsetlflags(struct tty *tp, struct termios *t);
52static int ttcompatspeedtab(int speed, struct speedtab *table);
53
54static int ttydebug = 0;
55SYSCTL_INT(_debug, OID_AUTO, ttydebug, CTLFLAG_RW, &ttydebug, 0, "");
56
57static struct speedtab compatspeeds[] = {
58#define MAX_SPEED	17
59	{ 115200, 17 },
60	{ 57600, 16 },
61	{ 38400, 15 },
62	{ 19200, 14 },
63	{ 9600,	13 },
64	{ 4800,	12 },
65	{ 2400,	11 },
66	{ 1800,	10 },
67	{ 1200,	9 },
68	{ 600,	8 },
69	{ 300,	7 },
70	{ 200,	6 },
71	{ 150,	5 },
72	{ 134,	4 },
73	{ 110,	3 },
74	{ 75,	2 },
75	{ 50,	1 },
76	{ 0,	0 },
77	{ -1,	-1 },
78};
79static int compatspcodes[] = {
80	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
81	1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200,
82};
83
84static int
85ttcompatspeedtab(int speed, struct speedtab *table)
86{
87	if (speed == 0)
88		return (0); /* hangup */
89	for ( ; table->sp_speed > 0; table++)
90		if (table->sp_speed <= speed) /* nearest one, rounded down */
91			return (table->sp_code);
92	return (1); /* 50, min and not hangup */
93}
94
95static int
96ttsetcompat(struct tty *tp, u_long *com, caddr_t data, struct termios *term)
97{
98	switch (*com) {
99	case TIOCSETP:
100	case TIOCSETN: {
101		struct sgttyb *sg = (struct sgttyb *)data;
102		int speed;
103
104		if ((speed = sg->sg_ispeed) > MAX_SPEED || speed < 0)
105			return(EINVAL);
106		else if (speed != ttcompatspeedtab(tp->t_termios.c_ispeed,
107		    compatspeeds))
108			term->c_ispeed = compatspcodes[speed];
109		else
110			term->c_ispeed = tp->t_termios.c_ispeed;
111		if ((speed = sg->sg_ospeed) > MAX_SPEED || speed < 0)
112			return(EINVAL);
113		else if (speed != ttcompatspeedtab(tp->t_termios.c_ospeed,
114		    compatspeeds))
115			term->c_ospeed = compatspcodes[speed];
116		else
117			term->c_ospeed = tp->t_termios.c_ospeed;
118		term->c_cc[VERASE] = sg->sg_erase;
119		term->c_cc[VKILL] = sg->sg_kill;
120		tp->t_compatflags = (tp->t_compatflags&0xffff0000) |
121		    (sg->sg_flags&0xffff);
122		ttcompatsetflags(tp, term);
123		*com = (*com == TIOCSETP) ? TIOCSETAF : TIOCSETA;
124		break;
125	}
126	case TIOCSETC: {
127		struct tchars *tc = (struct tchars *)data;
128		cc_t *cc;
129
130		cc = term->c_cc;
131		cc[VINTR] = tc->t_intrc;
132		cc[VQUIT] = tc->t_quitc;
133		cc[VSTART] = tc->t_startc;
134		cc[VSTOP] = tc->t_stopc;
135		cc[VEOF] = tc->t_eofc;
136		cc[VEOL] = tc->t_brkc;
137		if (tc->t_brkc == (char)_POSIX_VDISABLE)
138			cc[VEOL2] = _POSIX_VDISABLE;
139		*com = TIOCSETA;
140		break;
141	}
142	case TIOCSLTC: {
143		struct ltchars *ltc = (struct ltchars *)data;
144		cc_t *cc;
145
146		cc = term->c_cc;
147		cc[VSUSP] = ltc->t_suspc;
148		cc[VDSUSP] = ltc->t_dsuspc;
149		cc[VREPRINT] = ltc->t_rprntc;
150		cc[VDISCARD] = ltc->t_flushc;
151		cc[VWERASE] = ltc->t_werasc;
152		cc[VLNEXT] = ltc->t_lnextc;
153		*com = TIOCSETA;
154		break;
155	}
156	case TIOCLBIS:
157	case TIOCLBIC:
158	case TIOCLSET:
159		if (*com == TIOCLSET)
160			tp->t_compatflags = (tp->t_compatflags&0xffff) |
161			    *(int *)data<<16;
162		else {
163			tp->t_compatflags = (ttcompatgetflags(tp)&0xffff0000) |
164			    (tp->t_compatflags&0xffff);
165			if (*com == TIOCLBIS)
166				tp->t_compatflags |= *(int *)data<<16;
167			else
168				tp->t_compatflags &= ~(*(int *)data<<16);
169		}
170		ttcompatsetlflags(tp, term);
171		*com = TIOCSETA;
172		break;
173	}
174	return 0;
175}
176
177/*ARGSUSED*/
178int
179tty_ioctl_compat(struct tty *tp, u_long com, caddr_t data, int fflag,
180    struct thread *td)
181{
182	switch (com) {
183	case TIOCSETP:
184	case TIOCSETN:
185	case TIOCSETC:
186	case TIOCSLTC:
187	case TIOCLBIS:
188	case TIOCLBIC:
189	case TIOCLSET: {
190		struct termios term;
191		int error;
192
193		term = tp->t_termios;
194		if ((error = ttsetcompat(tp, &com, data, &term)) != 0)
195			return error;
196		return tty_ioctl(tp, com, &term, fflag, td);
197	}
198	case TIOCGETP: {
199		struct sgttyb *sg = (struct sgttyb *)data;
200		cc_t *cc = tp->t_termios.c_cc;
201
202		sg->sg_ospeed = ttcompatspeedtab(tp->t_termios.c_ospeed,
203		    compatspeeds);
204		if (tp->t_termios.c_ispeed == 0)
205			sg->sg_ispeed = sg->sg_ospeed;
206		else
207			sg->sg_ispeed = ttcompatspeedtab(tp->t_termios.c_ispeed,
208			    compatspeeds);
209		sg->sg_erase = cc[VERASE];
210		sg->sg_kill = cc[VKILL];
211		sg->sg_flags = tp->t_compatflags = ttcompatgetflags(tp);
212		break;
213	}
214	case TIOCGETC: {
215		struct tchars *tc = (struct tchars *)data;
216		cc_t *cc = tp->t_termios.c_cc;
217
218		tc->t_intrc = cc[VINTR];
219		tc->t_quitc = cc[VQUIT];
220		tc->t_startc = cc[VSTART];
221		tc->t_stopc = cc[VSTOP];
222		tc->t_eofc = cc[VEOF];
223		tc->t_brkc = cc[VEOL];
224		break;
225	}
226	case TIOCGLTC: {
227		struct ltchars *ltc = (struct ltchars *)data;
228		cc_t *cc = tp->t_termios.c_cc;
229
230		ltc->t_suspc = cc[VSUSP];
231		ltc->t_dsuspc = cc[VDSUSP];
232		ltc->t_rprntc = cc[VREPRINT];
233		ltc->t_flushc = cc[VDISCARD];
234		ltc->t_werasc = cc[VWERASE];
235		ltc->t_lnextc = cc[VLNEXT];
236		break;
237	}
238	case TIOCLGET:
239		tp->t_compatflags =
240		 (ttcompatgetflags(tp) & 0xffff0000UL)
241		   | (tp->t_compatflags & 0xffff);
242		*(int *)data = tp->t_compatflags>>16;
243		if (ttydebug)
244			printf("CLGET: returning %x\n", *(int *)data);
245		break;
246
247	case OTIOCGETD:
248		*(int *)data = 2;
249		break;
250
251	case OTIOCSETD: {
252		int ldisczero = 0;
253
254		return (tty_ioctl(tp, TIOCSETD,
255			*(int *)data == 2 ? (caddr_t)&ldisczero : data,
256			fflag, td));
257	    }
258
259	case OTIOCCONS: {
260		int one = 1;
261
262		return (tty_ioctl(tp, TIOCCONS, (caddr_t)&one, fflag, td));
263	}
264
265	default:
266		return (ENOIOCTL);
267	}
268	return (0);
269}
270
271static int
272ttcompatgetflags(struct tty *tp)
273{
274	tcflag_t iflag	= tp->t_termios.c_iflag;
275	tcflag_t lflag	= tp->t_termios.c_lflag;
276	tcflag_t oflag	= tp->t_termios.c_oflag;
277	tcflag_t cflag	= tp->t_termios.c_cflag;
278	int flags = 0;
279
280	if (iflag&IXOFF)
281		flags |= TANDEM;
282	if (iflag&ICRNL || oflag&ONLCR)
283		flags |= CRMOD;
284	if ((cflag&CSIZE) == CS8) {
285		flags |= PASS8;
286		if (iflag&ISTRIP)
287			flags |= ANYP;
288	}
289	else if (cflag&PARENB) {
290		if (iflag&INPCK) {
291			if (cflag&PARODD)
292				flags |= ODDP;
293			else
294				flags |= EVENP;
295		} else
296			flags |= EVENP | ODDP;
297	}
298
299	if ((lflag&ICANON) == 0) {
300		/* fudge */
301		if (iflag&(INPCK|ISTRIP|IXON) || lflag&(IEXTEN|ISIG)
302		    || (cflag&(CSIZE|PARENB)) != CS8)
303			flags |= CBREAK;
304		else
305			flags |= RAW;
306	}
307	if (!(flags&RAW) && !(oflag&OPOST) && (cflag&(CSIZE|PARENB)) == CS8)
308		flags |= LITOUT;
309	if (cflag&MDMBUF)
310		flags |= MDMBUF;
311	if ((cflag&HUPCL) == 0)
312		flags |= NOHANG;
313	if (oflag&TAB3)
314		flags |= XTABS;
315	if (lflag&ECHOE)
316		flags |= CRTERA|CRTBS;
317	if (lflag&ECHOKE)
318		flags |= CRTKIL|CRTBS;
319	if (lflag&ECHOPRT)
320		flags |= PRTERA;
321	if (lflag&ECHOCTL)
322		flags |= CTLECH;
323	if ((iflag&IXANY) == 0)
324		flags |= DECCTQ;
325	flags |= lflag&(ECHO|TOSTOP|FLUSHO|PENDIN|NOFLSH);
326	if (ttydebug)
327		printf("getflags: %x\n", flags);
328	return (flags);
329}
330
331static void
332ttcompatsetflags(struct tty *tp, struct termios *t)
333{
334	int flags = tp->t_compatflags;
335	tcflag_t iflag	= t->c_iflag;
336	tcflag_t oflag	= t->c_oflag;
337	tcflag_t lflag	= t->c_lflag;
338	tcflag_t cflag	= t->c_cflag;
339
340	if (flags & RAW) {
341		iflag = IGNBRK;
342		lflag &= ~(ECHOCTL|ISIG|ICANON|IEXTEN);
343	} else {
344		iflag &= ~(PARMRK|IGNPAR|IGNCR|INLCR);
345		iflag |= BRKINT|IXON|IMAXBEL;
346		lflag |= ISIG|IEXTEN|ECHOCTL;	/* XXX was echoctl on ? */
347		if (flags & XTABS)
348			oflag |= TAB3;
349		else
350			oflag &= ~TAB3;
351		if (flags & CBREAK)
352			lflag &= ~ICANON;
353		else
354			lflag |= ICANON;
355		if (flags&CRMOD) {
356			iflag |= ICRNL;
357			oflag |= ONLCR;
358		} else {
359			iflag &= ~ICRNL;
360			oflag &= ~ONLCR;
361		}
362	}
363	if (flags&ECHO)
364		lflag |= ECHO;
365	else
366		lflag &= ~ECHO;
367
368	cflag &= ~(CSIZE|PARENB);
369	if (flags&(RAW|LITOUT|PASS8)) {
370		cflag |= CS8;
371		if (!(flags&(RAW|PASS8))
372		    || (flags&(RAW|PASS8|ANYP)) == (PASS8|ANYP))
373			iflag |= ISTRIP;
374		else
375			iflag &= ~ISTRIP;
376		if (flags&(RAW|LITOUT))
377			oflag &= ~OPOST;
378		else
379			oflag |= OPOST;
380	} else {
381		cflag |= CS7|PARENB;
382		iflag |= ISTRIP;
383		oflag |= OPOST;
384	}
385	/* XXX don't set INPCK if RAW or PASS8? */
386	if ((flags&(EVENP|ODDP)) == EVENP) {
387		iflag |= INPCK;
388		cflag &= ~PARODD;
389	} else if ((flags&(EVENP|ODDP)) == ODDP) {
390		iflag |= INPCK;
391		cflag |= PARODD;
392	} else
393		iflag &= ~INPCK;
394	if (flags&TANDEM)
395		iflag |= IXOFF;
396	else
397		iflag &= ~IXOFF;
398	if ((flags&DECCTQ) == 0)
399		iflag |= IXANY;
400	else
401		iflag &= ~IXANY;
402	t->c_iflag = iflag;
403	t->c_oflag = oflag;
404	t->c_lflag = lflag;
405	t->c_cflag = cflag;
406}
407
408static void
409ttcompatsetlflags(struct tty *tp, struct termios *t)
410{
411	int flags = tp->t_compatflags;
412	tcflag_t iflag	= t->c_iflag;
413	tcflag_t oflag	= t->c_oflag;
414	tcflag_t lflag	= t->c_lflag;
415	tcflag_t cflag	= t->c_cflag;
416
417	iflag &= ~(PARMRK|IGNPAR|IGNCR|INLCR);
418	if (flags&CRTERA)
419		lflag |= ECHOE;
420	else
421		lflag &= ~ECHOE;
422	if (flags&CRTKIL)
423		lflag |= ECHOKE;
424	else
425		lflag &= ~ECHOKE;
426	if (flags&PRTERA)
427		lflag |= ECHOPRT;
428	else
429		lflag &= ~ECHOPRT;
430	if (flags&CTLECH)
431		lflag |= ECHOCTL;
432	else
433		lflag &= ~ECHOCTL;
434	if (flags&TANDEM)
435		iflag |= IXOFF;
436	else
437		iflag &= ~IXOFF;
438	if ((flags&DECCTQ) == 0)
439		iflag |= IXANY;
440	else
441		iflag &= ~IXANY;
442	if (flags & MDMBUF)
443		cflag |= MDMBUF;
444	else
445		cflag &= ~MDMBUF;
446	if (flags&NOHANG)
447		cflag &= ~HUPCL;
448	else
449		cflag |= HUPCL;
450	lflag &= ~(TOSTOP|FLUSHO|PENDIN|NOFLSH);
451	lflag |= flags&(TOSTOP|FLUSHO|PENDIN|NOFLSH);
452
453	/*
454	 * The next if-else statement is copied from above so don't bother
455	 * checking it separately.  We could avoid fiddlling with the
456	 * character size if the mode is already RAW or if neither the
457	 * LITOUT bit or the PASS8 bit is being changed, but the delta of
458	 * the change is not available here and skipping the RAW case would
459	 * make the code different from above.
460	 */
461	cflag &= ~(CSIZE|PARENB);
462	if (flags&(RAW|LITOUT|PASS8)) {
463		cflag |= CS8;
464		if (!(flags&(RAW|PASS8))
465		    || (flags&(RAW|PASS8|ANYP)) == (PASS8|ANYP))
466			iflag |= ISTRIP;
467		else
468			iflag &= ~ISTRIP;
469		if (flags&(RAW|LITOUT))
470			oflag &= ~OPOST;
471		else
472			oflag |= OPOST;
473	} else {
474		cflag |= CS7|PARENB;
475		iflag |= ISTRIP;
476		oflag |= OPOST;
477	}
478	t->c_iflag = iflag;
479	t->c_oflag = oflag;
480	t->c_lflag = lflag;
481	t->c_cflag = cflag;
482}
483