xref: /freebsd/sys/netgraph/ng_tty.c (revision 1670a1c2a47d10ecccd001970b859caf93cd3b6e)
1 /*
2  * ng_tty.c
3  */
4 
5 /*-
6  * Copyright (c) 1996-1999 Whistle Communications, Inc.
7  * All rights reserved.
8  *
9  * Subject to the following obligations and disclaimer of warranty, use and
10  * redistribution of this software, in source or object code forms, with or
11  * without modifications are expressly permitted by Whistle Communications;
12  * provided, however, that:
13  * 1. Any and all reproductions of the source or object code must include the
14  *    copyright notice above and the following disclaimer of warranties; and
15  * 2. No rights are granted, in any manner or form, to use Whistle
16  *    Communications, Inc. trademarks, including the mark "WHISTLE
17  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
18  *    such appears in the above copyright notice or in the software.
19  *
20  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
21  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
22  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
23  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
25  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
26  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
27  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
28  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
29  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
30  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
31  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
32  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
36  * OF SUCH DAMAGE.
37  *
38  * Author: Archie Cobbs <archie@freebsd.org>
39  *
40  * Updated by Andrew Thompson <thompsa@FreeBSD.org> for MPSAFE TTY.
41  *
42  * $FreeBSD$
43  * $Whistle: ng_tty.c,v 1.21 1999/11/01 09:24:52 julian Exp $
44  */
45 
46 /*
47  * This file implements TTY hooks to link in to the netgraph system.  The node
48  * is created and then passed the callers opened TTY file descriptor number to
49  * NGM_TTY_SET_TTY, this will hook the tty via ttyhook_register().
50  *
51  * Incoming data is delivered directly to ng_tty via the TTY bypass hook as a
52  * buffer pointer and length, this is converted to a mbuf and passed to the
53  * peer.
54  *
55  * If the TTY device does not support bypass then incoming characters are
56  * delivered to the hook one at a time, each in its own mbuf. You may
57  * optionally define a ``hotchar,'' which causes incoming characters to be
58  * buffered up until either the hotchar is seen or the mbuf is full (MHLEN
59  * bytes). Then all buffered characters are immediately delivered.
60  */
61 
62 #include <sys/param.h>
63 #include <sys/systm.h>
64 #include <sys/conf.h>
65 #include <sys/errno.h>
66 #include <sys/fcntl.h>
67 #include <sys/ioccom.h>
68 #include <sys/kernel.h>
69 #include <sys/malloc.h>
70 #include <sys/mbuf.h>
71 #include <sys/priv.h>
72 #include <sys/socket.h>
73 #include <sys/syslog.h>
74 #include <sys/tty.h>
75 #include <sys/ttycom.h>
76 #include <sys/proc.h>
77 
78 #include <net/if.h>
79 #include <net/if_var.h>
80 
81 #include <netgraph/ng_message.h>
82 #include <netgraph/netgraph.h>
83 #include <netgraph/ng_tty.h>
84 
85 /* Per-node private info */
86 struct ngt_softc {
87 	struct tty	*tp;		/* Terminal device */
88 	node_p		node;		/* Netgraph node */
89 	hook_p		hook;		/* Netgraph hook */
90 	struct ifqueue	outq;		/* Queue of outgoing data */
91 	size_t		outqlen;	/* Number of bytes in outq */
92 	struct mbuf	*m;		/* Incoming non-bypass data buffer */
93 	short		hotchar;	/* Hotchar, or -1 if none */
94 	u_int		flags;		/* Flags */
95 };
96 typedef struct ngt_softc *sc_p;
97 
98 /* Flags */
99 #define FLG_DEBUG		0x0002
100 
101 /* Netgraph methods */
102 static ng_constructor_t		ngt_constructor;
103 static ng_rcvmsg_t		ngt_rcvmsg;
104 static ng_shutdown_t		ngt_shutdown;
105 static ng_newhook_t		ngt_newhook;
106 static ng_connect_t		ngt_connect;
107 static ng_rcvdata_t		ngt_rcvdata;
108 static ng_disconnect_t		ngt_disconnect;
109 
110 #define ERROUT(x)		do { error = (x); goto done; } while (0)
111 
112 static th_getc_inject_t		ngt_getc_inject;
113 static th_getc_poll_t		ngt_getc_poll;
114 static th_rint_t		ngt_rint;
115 static th_rint_bypass_t		ngt_rint_bypass;
116 static th_rint_poll_t		ngt_rint_poll;
117 
118 static struct ttyhook ngt_hook = {
119 	.th_getc_inject = ngt_getc_inject,
120 	.th_getc_poll = ngt_getc_poll,
121 	.th_rint = ngt_rint,
122 	.th_rint_bypass = ngt_rint_bypass,
123 	.th_rint_poll = ngt_rint_poll,
124 };
125 
126 /* Netgraph node type descriptor */
127 static struct ng_type typestruct = {
128 	.version =	NG_ABI_VERSION,
129 	.name =		NG_TTY_NODE_TYPE,
130 	.constructor =	ngt_constructor,
131 	.rcvmsg =	ngt_rcvmsg,
132 	.shutdown =	ngt_shutdown,
133 	.newhook =	ngt_newhook,
134 	.connect =	ngt_connect,
135 	.rcvdata =	ngt_rcvdata,
136 	.disconnect =	ngt_disconnect,
137 };
138 NETGRAPH_INIT(tty, &typestruct);
139 
140 #define	NGTLOCK(sc)	IF_LOCK(&sc->outq)
141 #define	NGTUNLOCK(sc)	IF_UNLOCK(&sc->outq)
142 
143 /******************************************************************
144 		    NETGRAPH NODE METHODS
145 ******************************************************************/
146 
147 /*
148  * Initialize a new node of this type.
149  *
150  * We only allow nodes to be created as a result of setting
151  * the line discipline on a tty, so always return an error if not.
152  */
153 static int
154 ngt_constructor(node_p node)
155 {
156 	sc_p sc;
157 
158 	/* Allocate private structure */
159 	sc = malloc(sizeof(*sc), M_NETGRAPH, M_NOWAIT | M_ZERO);
160 	if (sc == NULL)
161 		return (ENOMEM);
162 
163 	NG_NODE_SET_PRIVATE(node, sc);
164 	sc->node = node;
165 
166 	mtx_init(&sc->outq.ifq_mtx, "ng_tty node+queue", NULL, MTX_DEF);
167 	IFQ_SET_MAXLEN(&sc->outq, ifqmaxlen);
168 
169 	return (0);
170 }
171 
172 /*
173  * Add a new hook. There can only be one.
174  */
175 static int
176 ngt_newhook(node_p node, hook_p hook, const char *name)
177 {
178 	const sc_p sc = NG_NODE_PRIVATE(node);
179 
180 	if (strcmp(name, NG_TTY_HOOK))
181 		return (EINVAL);
182 
183 	if (sc->hook)
184 		return (EISCONN);
185 
186 	NGTLOCK(sc);
187 	sc->hook = hook;
188 	NGTUNLOCK(sc);
189 
190 	return (0);
191 }
192 
193 /*
194  * Set the hook into queueing mode (for outgoing packets),
195  * so that we wont deliver mbuf thru the whole graph holding
196  * tty locks.
197  */
198 static int
199 ngt_connect(hook_p hook)
200 {
201 	NG_HOOK_FORCE_QUEUE(hook);
202 	return (0);
203 }
204 
205 /*
206  * Disconnect the hook
207  */
208 static int
209 ngt_disconnect(hook_p hook)
210 {
211 	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
212 
213 	if (hook != sc->hook)
214 		panic(__func__);
215 
216 	NGTLOCK(sc);
217 	sc->hook = NULL;
218 	NGTUNLOCK(sc);
219 
220 	return (0);
221 }
222 
223 /*
224  * Remove this node. The does the netgraph portion of the shutdown.
225  */
226 static int
227 ngt_shutdown(node_p node)
228 {
229 	const sc_p sc = NG_NODE_PRIVATE(node);
230 	struct tty *tp;
231 
232 	tp = sc->tp;
233 	if (tp != NULL) {
234 		tty_lock(tp);
235 		ttyhook_unregister(tp);
236 	}
237 	/* Free resources */
238 	IF_DRAIN(&sc->outq);
239 	mtx_destroy(&(sc)->outq.ifq_mtx);
240 	NG_NODE_UNREF(sc->node);
241 	free(sc, M_NETGRAPH);
242 
243 	return (0);
244 }
245 
246 /*
247  * Receive control message
248  */
249 static int
250 ngt_rcvmsg(node_p node, item_p item, hook_p lasthook)
251 {
252 	struct proc *p;
253 	const sc_p sc = NG_NODE_PRIVATE(node);
254 	struct ng_mesg *msg, *resp = NULL;
255 	int error = 0;
256 
257 	NGI_GET_MSG(item, msg);
258 	switch (msg->header.typecookie) {
259 	case NGM_TTY_COOKIE:
260 		switch (msg->header.cmd) {
261 		case NGM_TTY_SET_TTY:
262 			if (sc->tp != NULL)
263 				return (EBUSY);
264 
265 			p = pfind(((int *)msg->data)[0]);
266 			if (p == NULL || (p->p_flag & P_WEXIT))
267 				return (ESRCH);
268 			_PHOLD(p);
269 			PROC_UNLOCK(p);
270 			error = ttyhook_register(&sc->tp, p, ((int *)msg->data)[1],
271 			    &ngt_hook, sc);
272 			PRELE(p);
273 			if (error != 0)
274 				return (error);
275 			break;
276 		case NGM_TTY_SET_HOTCHAR:
277 		    {
278 			int     hotchar;
279 
280 			if (msg->header.arglen != sizeof(int))
281 				ERROUT(EINVAL);
282 			hotchar = *((int *) msg->data);
283 			if (hotchar != (u_char) hotchar && hotchar != -1)
284 				ERROUT(EINVAL);
285 			sc->hotchar = hotchar;	/* race condition is OK */
286 			break;
287 		    }
288 		case NGM_TTY_GET_HOTCHAR:
289 			NG_MKRESPONSE(resp, msg, sizeof(int), M_NOWAIT);
290 			if (!resp)
291 				ERROUT(ENOMEM);
292 			/* Race condition here is OK */
293 			*((int *) resp->data) = sc->hotchar;
294 			break;
295 		default:
296 			ERROUT(EINVAL);
297 		}
298 		break;
299 	default:
300 		ERROUT(EINVAL);
301 	}
302 done:
303 	NG_RESPOND_MSG(error, node, item, resp);
304 	NG_FREE_MSG(msg);
305 	return (error);
306 }
307 
308 /*
309  * Receive incoming data from netgraph system. Put it on our
310  * output queue and start output if necessary.
311  */
312 static int
313 ngt_rcvdata(hook_p hook, item_p item)
314 {
315 	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
316 	struct tty *tp = sc->tp;
317 	struct mbuf *m;
318 
319 	if (hook != sc->hook)
320 		panic(__func__);
321 
322 	NGI_GET_M(item, m);
323 	NG_FREE_ITEM(item);
324 
325 	if (tp == NULL) {
326 		NG_FREE_M(m);
327 		return (ENXIO);
328 	}
329 
330 	IF_LOCK(&sc->outq);
331 	if (_IF_QFULL(&sc->outq)) {
332 		_IF_DROP(&sc->outq);
333 		IF_UNLOCK(&sc->outq);
334 		NG_FREE_M(m);
335 		return (ENOBUFS);
336 	}
337 
338 	_IF_ENQUEUE(&sc->outq, m);
339 	sc->outqlen += m->m_pkthdr.len;
340 	IF_UNLOCK(&sc->outq);
341 
342 	/* notify the TTY that data is ready */
343 	tty_lock(tp);
344 	if (!tty_gone(tp))
345 		ttydevsw_outwakeup(tp);
346 	tty_unlock(tp);
347 
348 	return (0);
349 }
350 
351 static size_t
352 ngt_getc_inject(struct tty *tp, void *buf, size_t len)
353 {
354 	sc_p sc = ttyhook_softc(tp);
355 	size_t total = 0;
356 	int length;
357 
358 	while (len) {
359 		struct mbuf *m;
360 
361 		/* Remove first mbuf from queue */
362 		IF_DEQUEUE(&sc->outq, m);
363 		if (m == NULL)
364 			break;
365 
366 		/* Send as much of it as possible */
367 		while (m != NULL) {
368 			length = min(m->m_len, len);
369 			memcpy((char *)buf + total, mtod(m, char *), length);
370 
371 			m->m_data += length;
372 			m->m_len -= length;
373 			total += length;
374 			len -= length;
375 
376 			if (m->m_len > 0)
377 				break;	/* device can't take any more */
378 			m = m_free(m);
379 		}
380 
381 		/* Put remainder of mbuf chain (if any) back on queue */
382 		if (m != NULL) {
383 			IF_PREPEND(&sc->outq, m);
384 			break;
385 		}
386 	}
387 	IF_LOCK(&sc->outq);
388 	sc->outqlen -= total;
389 	IF_UNLOCK(&sc->outq);
390 	MPASS(sc->outqlen >= 0);
391 
392 	return (total);
393 }
394 
395 static size_t
396 ngt_getc_poll(struct tty *tp)
397 {
398 	sc_p sc = ttyhook_softc(tp);
399 
400 	return (sc->outqlen);
401 }
402 
403 /*
404  * Optimised TTY input.
405  *
406  * We get a buffer pointer to hopefully a complete data frame. Do not check for
407  * the hotchar, just pass it on.
408  */
409 static size_t
410 ngt_rint_bypass(struct tty *tp, const void *buf, size_t len)
411 {
412 	sc_p sc = ttyhook_softc(tp);
413 	node_p node = sc->node;
414 	struct mbuf *m, *mb;
415 	size_t total = 0;
416 	int error = 0, length;
417 
418 	tty_lock_assert(tp, MA_OWNED);
419 
420 	if (sc->hook == NULL)
421 		return (0);
422 
423 	m = m_getm2(NULL, len, M_DONTWAIT, MT_DATA, M_PKTHDR);
424 	if (m == NULL) {
425 		if (sc->flags & FLG_DEBUG)
426 			log(LOG_ERR,
427 			    "%s: can't get mbuf\n", NG_NODE_NAME(node));
428 		return (0);
429 	}
430 	m->m_pkthdr.rcvif = NULL;
431 
432 	for (mb = m; mb != NULL; mb = mb->m_next) {
433 		length = min(M_TRAILINGSPACE(mb), len - total);
434 
435 		memcpy(mtod(m, char *), (const char *)buf + total, length);
436 		mb->m_len = length;
437 		total += length;
438 		m->m_pkthdr.len += length;
439 	}
440 	if (sc->m != NULL) {
441 		/*
442 		 * Odd, we have changed from non-bypass to bypass. It is
443 		 * unlikely but not impossible, flush the data first.
444 		 */
445 		sc->m->m_data = sc->m->m_pktdat;
446 		NG_SEND_DATA_ONLY(error, sc->hook, sc->m);
447 		sc->m = NULL;
448 	}
449 	NG_SEND_DATA_ONLY(error, sc->hook, m);
450 
451 	return (total);
452 }
453 
454 /*
455  * Receive data coming from the device one char at a time, when it is not in
456  * bypass mode.
457  */
458 static int
459 ngt_rint(struct tty *tp, char c, int flags)
460 {
461 	sc_p sc = ttyhook_softc(tp);
462 	node_p node = sc->node;
463 	struct mbuf *m;
464 	int error = 0;
465 
466 	tty_lock_assert(tp, MA_OWNED);
467 
468 	if (sc->hook == NULL)
469 		return (0);
470 
471 	if (flags != 0) {
472 		/* framing error or overrun on this char */
473 		if (sc->flags & FLG_DEBUG)
474 			log(LOG_DEBUG, "%s: line error %x\n",
475 			    NG_NODE_NAME(node), flags);
476 		return (0);
477 	}
478 
479 	/* Get a new header mbuf if we need one */
480 	if (!(m = sc->m)) {
481 		MGETHDR(m, M_DONTWAIT, MT_DATA);
482 		if (!m) {
483 			if (sc->flags & FLG_DEBUG)
484 				log(LOG_ERR,
485 				    "%s: can't get mbuf\n", NG_NODE_NAME(node));
486 			return (ENOBUFS);
487 		}
488 		m->m_len = m->m_pkthdr.len = 0;
489 		m->m_pkthdr.rcvif = NULL;
490 		sc->m = m;
491 	}
492 
493 	/* Add char to mbuf */
494 	*mtod(m, u_char *) = c;
495 	m->m_data++;
496 	m->m_len++;
497 	m->m_pkthdr.len++;
498 
499 	/* Ship off mbuf if it's time */
500 	if (sc->hotchar == -1 || c == sc->hotchar || m->m_len >= MHLEN) {
501 		m->m_data = m->m_pktdat;
502 		sc->m = NULL;
503 		NG_SEND_DATA_ONLY(error, sc->hook, m);	/* Will queue */
504 	}
505 
506 	return (error);
507 }
508 
509 static size_t
510 ngt_rint_poll(struct tty *tp)
511 {
512 	/* We can always accept input */
513 	return (1);
514 }
515 
516