xref: /freebsd/sys/netgraph/ng_frame_relay.c (revision 3642298923e528d795e3a30ec165d2b469e28b40)
1 /*
2  * ng_frame_relay.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: Julian Elischer <julian@freebsd.org>
39  *
40  * $FreeBSD$
41  * $Whistle: ng_frame_relay.c,v 1.20 1999/11/01 09:24:51 julian Exp $
42  */
43 
44 /*
45  * This node implements the frame relay protocol, not including
46  * the LMI line management. This means basically keeping track
47  * of which DLCI's are active, doing frame (de)multiplexing, etc.
48  *
49  * It has a 'downstream' hook that goes to the line, and a
50  * hook for each DLCI (eg, 'dlci16').
51  */
52 
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/kernel.h>
56 #include <sys/errno.h>
57 #include <sys/malloc.h>
58 #include <sys/mbuf.h>
59 #include <sys/syslog.h>
60 #include <sys/ctype.h>
61 
62 #include <netgraph/ng_message.h>
63 #include <netgraph/netgraph.h>
64 #include <netgraph/ng_frame_relay.h>
65 
66 /*
67  * Line info, and status per channel.
68  */
69 struct ctxinfo {		/* one per active hook */
70 	u_int   flags;
71 #define CHAN_VALID	0x01	/* assigned to a channel */
72 #define CHAN_ACTIVE	0x02	/* bottom level active */
73 	int     dlci;		/* the dlci assigned to this context */
74 	hook_p  hook;		/* if there's a hook assigned.. */
75 };
76 
77 #define MAX_CT 16		/* # of dlci's active at a time (POWER OF 2!) */
78 struct frmrel_softc {
79 	int     unit;		/* which card are we? */
80 	int     datahooks;	/* number of data hooks attached */
81 	node_p  node;		/* netgraph node */
82 	int     addrlen;	/* address header length */
83 	int     flags;		/* state */
84 	int     mtu;		/* guess */
85 	u_char  remote_seq;	/* sequence number the remote sent */
86 	u_char  local_seq;	/* sequence number the remote rcvd */
87 	u_short ALT[1024];	/* map DLCIs to CTX */
88 #define	CTX_VALID	0x8000		/* this bit means it's a valid CTX */
89 #define	CTX_VALUE	(MAX_CT - 1)	/* mask for context part */
90 	struct	ctxinfo channel[MAX_CT];
91 	struct	ctxinfo downstream;
92 };
93 typedef struct frmrel_softc *sc_p;
94 
95 #define BYTEX_EA	0x01	/* End Address. Always 0 on byte1 */
96 #define BYTE1_C_R	0x02
97 #define BYTE2_FECN	0x08	/* forwards congestion notification */
98 #define BYTE2_BECN	0x04	/* Backward congestion notification */
99 #define BYTE2_DE	0x02	/* Discard elligability */
100 #define LASTBYTE_D_C	0x02	/* last byte is dl_core or dlci info */
101 
102 /* Used to do headers */
103 const static struct segment {
104 	u_char  mask;
105 	u_char  shift;
106 	u_char  width;
107 } makeup[] = {
108 	{ 0xfc, 2, 6 },
109 	{ 0xf0, 4, 4 },
110 	{ 0xfe, 1, 7 },
111 	{ 0xfc, 2, 6 }
112 };
113 
114 #define SHIFTIN(segment, byte, dlci) 					     \
115 	{								     \
116 		(dlci) <<= (segment)->width;				     \
117 		(dlci) |=						     \
118 			(((byte) & (segment)->mask) >> (segment)->shift);    \
119 	}
120 
121 #define SHIFTOUT(segment, byte, dlci)					     \
122 	{								     \
123 		(byte) |= (((dlci) << (segment)->shift) & (segment)->mask);  \
124 		(dlci) >>= (segment)->width;				     \
125 	}
126 
127 /* Netgraph methods */
128 static ng_constructor_t	ngfrm_constructor;
129 static ng_shutdown_t	ngfrm_shutdown;
130 static ng_newhook_t	ngfrm_newhook;
131 static ng_rcvdata_t	ngfrm_rcvdata;
132 static ng_disconnect_t	ngfrm_disconnect;
133 
134 /* Other internal functions */
135 static int ngfrm_decode(node_p node, item_p item);
136 static int ngfrm_addrlen(char *hdr);
137 static int ngfrm_allocate_CTX(sc_p sc, int dlci);
138 
139 /* Netgraph type */
140 static struct ng_type typestruct = {
141 	.version =	NG_ABI_VERSION,
142 	.name =		NG_FRAMERELAY_NODE_TYPE,
143 	.constructor =	ngfrm_constructor,
144 	.shutdown =	ngfrm_shutdown,
145 	.newhook =	ngfrm_newhook,
146 	.rcvdata =	ngfrm_rcvdata,
147 	.disconnect =	ngfrm_disconnect,
148 };
149 NETGRAPH_INIT(framerelay, &typestruct);
150 
151 /*
152  * Given a DLCI, return the index of the  context table entry for it,
153  * Allocating a new one if needs be, or -1 if none available.
154  */
155 static int
156 ngfrm_allocate_CTX(sc_p sc, int dlci)
157 {
158 	u_int   ctxnum = -1;	/* what ctx number we are using */
159 	volatile struct ctxinfo *CTXp = NULL;
160 
161 	/* Sanity check the dlci value */
162 	if (dlci > 1023)
163 		return (-1);
164 
165 	/* Check to see if we already have an entry for this DLCI */
166 	if (sc->ALT[dlci]) {
167 		if ((ctxnum = sc->ALT[dlci] & CTX_VALUE) < MAX_CT) {
168 			CTXp = sc->channel + ctxnum;
169 		} else {
170 			ctxnum = -1;
171 			sc->ALT[dlci] = 0;	/* paranoid but... */
172 		}
173 	}
174 
175 	/*
176 	 * If the index has no valid entry yet, then we need to allocate a
177 	 * CTX number to it
178 	 */
179 	if (CTXp == NULL) {
180 		for (ctxnum = 0; ctxnum < MAX_CT; ctxnum++) {
181 			/*
182 			 * If the VALID flag is empty it is unused
183 			 */
184 			if ((sc->channel[ctxnum].flags & CHAN_VALID) == 0) {
185 				bzero(sc->channel + ctxnum,
186 				      sizeof(struct ctxinfo));
187 				CTXp = sc->channel + ctxnum;
188 				sc->ALT[dlci] = ctxnum | CTX_VALID;
189 				sc->channel[ctxnum].dlci = dlci;
190 				sc->channel[ctxnum].flags = CHAN_VALID;
191 				break;
192 			}
193 		}
194 	}
195 
196 	/*
197 	 * If we still don't have a CTX pointer, then we never found a free
198 	 * spot so give up now..
199 	 */
200 	if (!CTXp) {
201 		log(LOG_ERR, "No CTX available for dlci %d\n", dlci);
202 		return (-1);
203 	}
204 	return (ctxnum);
205 }
206 
207 /*
208  * Node constructor
209  */
210 static int
211 ngfrm_constructor(node_p node)
212 {
213 	sc_p sc;
214 
215 	MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_NOWAIT | M_ZERO);
216 	if (!sc)
217 		return (ENOMEM);
218 	sc->addrlen = 2;	/* default */
219 
220 	/* Link the node and our private info */
221 	NG_NODE_SET_PRIVATE(node, sc);
222 	sc->node = node;
223 	return (0);
224 }
225 
226 /*
227  * Add a new hook
228  *
229  * We allow hooks called "debug", "downstream" and dlci[0-1023]
230  * The hook's private info points to our stash of info about that
231  * channel. A NULL pointer is debug and a DLCI of -1 means downstream.
232  */
233 static int
234 ngfrm_newhook(node_p node, hook_p hook, const char *name)
235 {
236 	const sc_p sc = NG_NODE_PRIVATE(node);
237 	const char *cp;
238 	char *eptr;
239 	int dlci = 0;
240 	int ctxnum;
241 
242 	/* Check if it's our friend the control hook */
243 	if (strcmp(name, NG_FRAMERELAY_HOOK_DEBUG) == 0) {
244 		NG_HOOK_SET_PRIVATE(hook, NULL);	/* paranoid */
245 		return (0);
246 	}
247 
248 	/*
249 	 * All other hooks either start with 'dlci' and have a decimal
250 	 * trailing channel number up to 4 digits, or are the downstream
251 	 * hook.
252 	 */
253 	if (strncmp(name, NG_FRAMERELAY_HOOK_DLCI,
254 	    strlen(NG_FRAMERELAY_HOOK_DLCI)) != 0) {
255 
256 		/* It must be the downstream connection */
257 		if (strcmp(name, NG_FRAMERELAY_HOOK_DOWNSTREAM) != 0)
258 			return EINVAL;
259 
260 		/* Make sure we haven't already got one (paranoid) */
261 		if (sc->downstream.hook)
262 			return (EADDRINUSE);
263 
264 		/* OK add it */
265 		NG_HOOK_SET_PRIVATE(hook, &sc->downstream);
266 		sc->downstream.hook = hook;
267 		sc->downstream.dlci = -1;
268 		sc->downstream.flags |= CHAN_ACTIVE;
269 		sc->datahooks++;
270 		return (0);
271 	}
272 
273 	/* Must be a dlci hook at this point */
274 	cp = name + strlen(NG_FRAMERELAY_HOOK_DLCI);
275 	if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0'))
276 		return (EINVAL);
277 	dlci = (int)strtoul(cp, &eptr, 10);
278 	if (*eptr != '\0' || dlci < 0 || dlci > 1023)
279 		return (EINVAL);
280 
281 	/*
282 	 * We have a dlci, now either find it, or allocate it. It's possible
283 	 * that we might have seen packets for it already and made an entry
284 	 * for it.
285 	 */
286 	ctxnum = ngfrm_allocate_CTX(sc, dlci);
287 	if (ctxnum == -1)
288 		return (ENOBUFS);
289 
290 	/*
291 	 * Be paranoid: if it's got a hook already, that dlci is in use .
292 	 * Generic code can not catch all the synonyms (e.g. dlci016 vs
293 	 * dlci16)
294 	 */
295 	if (sc->channel[ctxnum].hook != NULL)
296 		return (EADDRINUSE);
297 
298 	/*
299 	 * Put our hooks into it (pun not intended)
300 	 */
301 	sc->channel[ctxnum].flags |= CHAN_ACTIVE;
302 	NG_HOOK_SET_PRIVATE(hook, sc->channel + ctxnum);
303 	sc->channel[ctxnum].hook = hook;
304 	sc->datahooks++;
305 	return (0);
306 }
307 
308 /*
309  * Count up the size of the address header if we don't already know
310  */
311 int
312 ngfrm_addrlen(char *hdr)
313 {
314 	if (hdr[0] & BYTEX_EA)
315 		return 0;
316 	if (hdr[1] & BYTEX_EA)
317 		return 2;
318 	if (hdr[2] & BYTEX_EA)
319 		return 3;
320 	if (hdr[3] & BYTEX_EA)
321 		return 4;
322 	return 0;
323 }
324 
325 /*
326  * Receive data packet
327  */
328 static int
329 ngfrm_rcvdata(hook_p hook, item_p item)
330 {
331 	struct	ctxinfo *const ctxp = NG_HOOK_PRIVATE(hook);
332 	int     error = 0;
333 	int     dlci;
334 	sc_p    sc;
335 	int     alen;
336 	char   *data;
337 	struct mbuf *m;
338 
339 	/* Data doesn't come in from just anywhere (e.g debug hook) */
340 	if (ctxp == NULL) {
341 		error = ENETDOWN;
342 		goto bad;
343 	}
344 
345 	/* If coming from downstream, decode it to a channel */
346 	dlci = ctxp->dlci;
347 	if (dlci == -1)
348 		return (ngfrm_decode(NG_HOOK_NODE(hook), item));
349 
350 	NGI_GET_M(item, m);
351 	/* Derive the softc we will need */
352 	sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
353 
354 	/* If there is no live channel, throw it away */
355 	if ((sc->downstream.hook == NULL)
356 	    || ((ctxp->flags & CHAN_ACTIVE) == 0)) {
357 		error = ENETDOWN;
358 		goto bad;
359 	}
360 
361 	/* Store the DLCI on the front of the packet */
362 	alen = sc->addrlen;
363 	if (alen == 0)
364 		alen = 2;	/* default value for transmit */
365 	M_PREPEND(m, alen, M_DONTWAIT);
366 	if (m == NULL) {
367 		error = ENOBUFS;
368 		goto bad;
369 	}
370 	data = mtod(m, char *);
371 
372 	/*
373 	 * Shift the lowest bits into the address field untill we are done.
374 	 * First byte is MSBits of addr so work backwards.
375 	 */
376 	switch (alen) {
377 	case 2:
378 		data[0] = data[1] = '\0';
379 		SHIFTOUT(makeup + 1, data[1], dlci);
380 		SHIFTOUT(makeup + 0, data[0], dlci);
381 		data[1] |= BYTEX_EA;
382 		break;
383 	case 3:
384 		data[0] = data[1] = data[2] = '\0';
385 		SHIFTOUT(makeup + 3, data[2], dlci);	/* 3 and 2 is correct */
386 		SHIFTOUT(makeup + 1, data[1], dlci);
387 		SHIFTOUT(makeup + 0, data[0], dlci);
388 		data[2] |= BYTEX_EA;
389 		break;
390 	case 4:
391 		data[0] = data[1] = data[2] = data[3] = '\0';
392 		SHIFTOUT(makeup + 3, data[3], dlci);
393 		SHIFTOUT(makeup + 2, data[2], dlci);
394 		SHIFTOUT(makeup + 1, data[1], dlci);
395 		SHIFTOUT(makeup + 0, data[0], dlci);
396 		data[3] |= BYTEX_EA;
397 		break;
398 	default:
399 		panic(__func__);
400 	}
401 
402 	/* Send it */
403 	NG_FWD_NEW_DATA(error, item, sc->downstream.hook, m);
404 	return (error);
405 
406 bad:
407 	NG_FREE_ITEM(item);
408 	NG_FREE_M(m);
409 	return (error);
410 }
411 
412 /*
413  * Decode an incoming frame coming from the switch
414  */
415 static int
416 ngfrm_decode(node_p node, item_p item)
417 {
418 	const sc_p  sc = NG_NODE_PRIVATE(node);
419 	char       *data;
420 	int         alen;
421 	u_int	    dlci = 0;
422 	int	    error = 0;
423 	int	    ctxnum;
424 	struct mbuf *m;
425 
426 	NGI_GET_M(item, m);
427 	if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL) {
428 		error = ENOBUFS;
429 		goto out;
430 	}
431 	data = mtod(m, char *);
432 	if ((alen = sc->addrlen) == 0) {
433 		sc->addrlen = alen = ngfrm_addrlen(data);
434 	}
435 	switch (alen) {
436 	case 2:
437 		SHIFTIN(makeup + 0, data[0], dlci);
438 		SHIFTIN(makeup + 1, data[1], dlci);
439 		break;
440 	case 3:
441 		SHIFTIN(makeup + 0, data[0], dlci);
442 		SHIFTIN(makeup + 1, data[1], dlci);
443 		SHIFTIN(makeup + 3, data[2], dlci);	/* 3 and 2 is correct */
444 		break;
445 	case 4:
446 		SHIFTIN(makeup + 0, data[0], dlci);
447 		SHIFTIN(makeup + 1, data[1], dlci);
448 		SHIFTIN(makeup + 2, data[2], dlci);
449 		SHIFTIN(makeup + 3, data[3], dlci);
450 		break;
451 	default:
452 		error = EINVAL;
453 		goto out;
454 	}
455 
456 	if (dlci > 1023) {
457 		error = EINVAL;
458 		goto out;
459 	}
460 	ctxnum = sc->ALT[dlci];
461 	if ((ctxnum & CTX_VALID) && sc->channel[ctxnum &= CTX_VALUE].hook) {
462 		/* Send it */
463 		m_adj(m, alen);
464 		NG_FWD_NEW_DATA(error, item, sc->channel[ctxnum].hook, m);
465 		return (error);
466 	} else {
467 		error = ENETDOWN;
468 	}
469 out:
470 	NG_FREE_ITEM(item);
471 	NG_FREE_M(m);
472 	return (error);
473 }
474 
475 /*
476  * Shutdown node
477  */
478 static int
479 ngfrm_shutdown(node_p node)
480 {
481 	const sc_p sc = NG_NODE_PRIVATE(node);
482 
483 	NG_NODE_SET_PRIVATE(node, NULL);
484 	FREE(sc, M_NETGRAPH);
485 	NG_NODE_UNREF(node);
486 	return (0);
487 }
488 
489 /*
490  * Hook disconnection
491  *
492  * Invalidate the private data associated with this dlci.
493  * For this type, removal of the last link resets tries to destroy the node.
494  */
495 static int
496 ngfrm_disconnect(hook_p hook)
497 {
498 	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
499 	struct ctxinfo *const cp = NG_HOOK_PRIVATE(hook);
500 	int dlci;
501 
502 	/* If it's a regular dlci hook, then free resources etc.. */
503 	if (cp != NULL) {
504 		cp->hook = NULL;
505 		dlci = cp->dlci;
506 		if (dlci != -1)
507 			sc->ALT[dlci] = 0;
508 		cp->flags = 0;
509 		sc->datahooks--;
510 	}
511 	if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
512 	&& (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
513 		ng_rmnode_self(NG_HOOK_NODE(hook));
514 	return (0);
515 }
516