6 * Copyright (c) 1996-1999 Whistle Communications, Inc.
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.
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
38 * Author: Archie Cobbs <archie@freebsd.org>
39 * $Whistle: ng_async.c,v 1.17 1999/11/01 09:24:51 julian Exp $
43 * This node type implements a PPP style sync <-> async converter.
44 * See RFC 1661 for details of how asynchronous encoding works.
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
51 #include <sys/malloc.h>
52 #include <sys/errno.h>
54 #include <netgraph/ng_message.h>
55 #include <netgraph/netgraph.h>
56 #include <netgraph/ng_async.h>
57 #include <netgraph/ng_parse.h>
59 #include <net/ppp_defs.h>
61 #ifdef NG_SEPARATE_MALLOC
62 static MALLOC_DEFINE(M_NETGRAPH_ASYNC, "netgraph_async", "netgraph async node");
64 #define M_NETGRAPH_ASYNC M_NETGRAPH
67 /* Async decode state */
72 /* Private data structure */
73 struct ng_async_private {
74 node_p node; /* Our node */
75 hook_p async; /* Asynchronous side */
76 hook_p sync; /* Synchronous side */
77 u_char amode; /* Async hunt/esape mode */
78 u_int16_t fcs; /* Decoded async FCS (so far) */
79 u_char *abuf; /* Buffer to encode sync into */
80 u_char *sbuf; /* Buffer to decode async into */
81 u_int slen; /* Length of data in sbuf */
82 long lasttime; /* Time of last async packet sent */
83 struct ng_async_cfg cfg; /* Configuration */
84 struct ng_async_stat stats; /* Statistics */
86 typedef struct ng_async_private *sc_p;
89 #define ASYNC_BUF_SIZE(smru) (2 * (smru) + 10)
90 #define SYNC_BUF_SIZE(amru) ((amru) + 10)
91 #define ERROUT(x) do { error = (x); goto done; } while (0)
93 /* Netgraph methods */
94 static ng_constructor_t nga_constructor;
95 static ng_rcvdata_t nga_rcvdata;
96 static ng_rcvmsg_t nga_rcvmsg;
97 static ng_shutdown_t nga_shutdown;
98 static ng_newhook_t nga_newhook;
99 static ng_disconnect_t nga_disconnect;
102 static int nga_rcv_sync(const sc_p sc, item_p item);
103 static int nga_rcv_async(const sc_p sc, item_p item);
105 /* Parse type for struct ng_async_cfg */
106 static const struct ng_parse_struct_field nga_config_type_fields[]
107 = NG_ASYNC_CONFIG_TYPE_INFO;
108 static const struct ng_parse_type nga_config_type = {
109 &ng_parse_struct_type,
110 &nga_config_type_fields
113 /* Parse type for struct ng_async_stat */
114 static const struct ng_parse_struct_field nga_stats_type_fields[]
115 = NG_ASYNC_STATS_TYPE_INFO;
116 static const struct ng_parse_type nga_stats_type = {
117 &ng_parse_struct_type,
118 &nga_stats_type_fields
121 /* List of commands and how to convert arguments to/from ASCII */
122 static const struct ng_cmdlist nga_cmdlist[] = {
125 NGM_ASYNC_CMD_SET_CONFIG,
132 NGM_ASYNC_CMD_GET_CONFIG,
139 NGM_ASYNC_CMD_GET_STATS,
146 NGM_ASYNC_CMD_CLR_STATS,
154 /* Define the netgraph node type */
155 static struct ng_type typestruct = {
156 .version = NG_ABI_VERSION,
157 .name = NG_ASYNC_NODE_TYPE,
158 .constructor = nga_constructor,
159 .rcvmsg = nga_rcvmsg,
160 .shutdown = nga_shutdown,
161 .newhook = nga_newhook,
162 .rcvdata = nga_rcvdata,
163 .disconnect = nga_disconnect,
164 .cmdlist = nga_cmdlist
166 NETGRAPH_INIT(async, &typestruct);
169 static const u_int16_t fcstab[];
171 /******************************************************************
172 NETGRAPH NODE METHODS
173 ******************************************************************/
176 * Initialize a new node
179 nga_constructor(node_p node)
183 sc = malloc(sizeof(*sc), M_NETGRAPH_ASYNC, M_WAITOK | M_ZERO);
184 sc->amode = MODE_HUNT;
186 sc->cfg.amru = NG_ASYNC_DEFAULT_MRU;
187 sc->cfg.smru = NG_ASYNC_DEFAULT_MRU;
188 sc->abuf = malloc(ASYNC_BUF_SIZE(sc->cfg.smru),
189 M_NETGRAPH_ASYNC, M_WAITOK);
190 sc->sbuf = malloc(SYNC_BUF_SIZE(sc->cfg.amru),
191 M_NETGRAPH_ASYNC, M_WAITOK);
192 NG_NODE_SET_PRIVATE(node, sc);
198 * Reserve a hook for a pending connection
201 nga_newhook(node_p node, hook_p hook, const char *name)
203 const sc_p sc = NG_NODE_PRIVATE(node);
206 if (!strcmp(name, NG_ASYNC_HOOK_ASYNC)) {
208 * We use a static buffer here so only one packet
209 * at a time can be allowed to travel in this direction.
210 * Force Writer semantics.
212 NG_HOOK_FORCE_WRITER(hook);
214 } else if (!strcmp(name, NG_ASYNC_HOOK_SYNC)) {
216 * We use a static state here so only one packet
217 * at a time can be allowed to travel in this direction.
218 * Force Writer semantics.
219 * Since we set this for both directions
220 * we might as well set it for the whole node
221 * bit I haven;t done that (yet).
223 NG_HOOK_FORCE_WRITER(hook);
228 if (*hookp) /* actually can't happen I think [JRE] */
235 * Receive incoming data
238 nga_rcvdata(hook_p hook, item_p item)
240 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
242 if (hook == sc->sync)
243 return (nga_rcv_sync(sc, item));
244 if (hook == sc->async)
245 return (nga_rcv_async(sc, item));
246 panic("%s", __func__);
250 * Receive incoming control message
253 nga_rcvmsg(node_p node, item_p item, hook_p lasthook)
255 const sc_p sc = NG_NODE_PRIVATE(node);
256 struct ng_mesg *resp = NULL;
260 NGI_GET_MSG(item, msg);
261 switch (msg->header.typecookie) {
262 case NGM_ASYNC_COOKIE:
263 switch (msg->header.cmd) {
264 case NGM_ASYNC_CMD_GET_STATS:
265 NG_MKRESPONSE(resp, msg, sizeof(sc->stats), M_NOWAIT);
268 *((struct ng_async_stat *) resp->data) = sc->stats;
270 case NGM_ASYNC_CMD_CLR_STATS:
271 bzero(&sc->stats, sizeof(sc->stats));
273 case NGM_ASYNC_CMD_SET_CONFIG:
275 struct ng_async_cfg *const cfg =
276 (struct ng_async_cfg *) msg->data;
279 if (msg->header.arglen != sizeof(*cfg))
281 if (cfg->amru < NG_ASYNC_MIN_MRU
282 || cfg->amru > NG_ASYNC_MAX_MRU
283 || cfg->smru < NG_ASYNC_MIN_MRU
284 || cfg->smru > NG_ASYNC_MAX_MRU)
286 cfg->enabled = !!cfg->enabled; /* normalize */
287 if (cfg->smru > sc->cfg.smru) { /* reallocate buffer */
288 buf = malloc(ASYNC_BUF_SIZE(cfg->smru),
289 M_NETGRAPH_ASYNC, M_NOWAIT);
292 free(sc->abuf, M_NETGRAPH_ASYNC);
295 if (cfg->amru > sc->cfg.amru) { /* reallocate buffer */
296 buf = malloc(SYNC_BUF_SIZE(cfg->amru),
297 M_NETGRAPH_ASYNC, M_NOWAIT);
300 free(sc->sbuf, M_NETGRAPH_ASYNC);
302 sc->amode = MODE_HUNT;
306 sc->amode = MODE_HUNT;
312 case NGM_ASYNC_CMD_GET_CONFIG:
313 NG_MKRESPONSE(resp, msg, sizeof(sc->cfg), M_NOWAIT);
316 *((struct ng_async_cfg *) resp->data) = sc->cfg;
326 NG_RESPOND_MSG(error, node, item, resp);
335 nga_shutdown(node_p node)
337 const sc_p sc = NG_NODE_PRIVATE(node);
339 free(sc->abuf, M_NETGRAPH_ASYNC);
340 free(sc->sbuf, M_NETGRAPH_ASYNC);
341 bzero(sc, sizeof(*sc));
342 free(sc, M_NETGRAPH_ASYNC);
343 NG_NODE_SET_PRIVATE(node, NULL);
349 * Lose a hook. When both hooks go away, we disappear.
352 nga_disconnect(hook_p hook)
354 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
357 if (hook == sc->async)
359 else if (hook == sc->sync)
362 panic("%s", __func__);
364 panic("%s 2", __func__);
366 bzero(&sc->stats, sizeof(sc->stats));
368 if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
369 && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
370 ng_rmnode_self(NG_HOOK_NODE(hook));
374 /******************************************************************
375 INTERNAL HELPER STUFF
376 ******************************************************************/
379 * Encode a byte into the async buffer
382 nga_async_add(const sc_p sc, u_int16_t *fcs, u_int32_t accm, int *len, u_char x)
384 *fcs = PPP_FCS(*fcs, x);
385 if ((x < 32 && ((1 << x) & accm))
387 || (x == PPP_FLAG)) {
388 sc->abuf[(*len)++] = PPP_ESCAPE;
391 sc->abuf[(*len)++] = x;
395 * Receive incoming synchronous data.
398 nga_rcv_sync(const sc_p sc, item_p item)
407 #define ADD_BYTE(x) nga_async_add(sc, &fcs, accm, &alen, (x))
409 /* Check for bypass mode */
410 if (!sc->cfg.enabled) {
411 NG_FWD_ITEM_HOOK(error, item, sc->async );
416 rcvif = m->m_pkthdr.rcvif;
418 /* Get ACCM; special case LCP frames, which use full ACCM */
420 if (m->m_pkthdr.len >= 4) {
421 static const u_char lcphdr[4] = {
424 (u_char)(PPP_LCP >> 8),
425 (u_char)(PPP_LCP & 0xff)
429 m_copydata(m, 0, 4, (caddr_t)buf);
430 if (bcmp(buf, &lcphdr, 4) == 0)
434 /* Check for overflow */
435 if (m->m_pkthdr.len > sc->cfg.smru) {
436 sc->stats.syncOverflows++;
443 sc->stats.syncFrames++;
444 sc->stats.syncOctets += m->m_pkthdr.len;
446 /* Initialize async encoded version of input mbuf */
450 /* Add beginning sync flag if it's been long enough to need one */
452 if (time.tv_sec >= sc->lasttime + 1) {
453 sc->abuf[alen++] = PPP_FLAG;
454 sc->lasttime = time.tv_sec;
457 /* Add packet payload */
459 while (m->m_len > 0) {
460 ADD_BYTE(*mtod(m, u_char *));
467 /* Add checksum and final sync flag */
469 ADD_BYTE(~fcs0 & 0xff);
470 ADD_BYTE(~fcs0 >> 8);
471 sc->abuf[alen++] = PPP_FLAG;
473 /* Put frame in an mbuf and ship it off */
474 if (!(m = m_devget(sc->abuf, alen, 0, rcvif, NULL))) {
478 NG_FWD_NEW_DATA(error, item, sc->async, m);
484 * Receive incoming asynchronous data
485 * XXX Technically, we should strip out incoming characters
486 * that are in our ACCM. Not sure if this is good or not.
489 nga_rcv_async(const sc_p sc, item_p item)
495 if (!sc->cfg.enabled) {
496 NG_FWD_ITEM_HOOK(error, item, sc->sync);
500 rcvif = m->m_pkthdr.rcvif;
504 for (; m->m_len > 0; m->m_data++, m->m_len--) {
505 u_char ch = *mtod(m, u_char *);
507 sc->stats.asyncOctets++;
508 if (ch == PPP_FLAG) { /* Flag overrides everything */
511 /* Check for runts */
514 sc->stats.asyncRunts++;
519 if (sc->fcs != PPP_GOODFCS) {
520 sc->stats.asyncBadCheckSums++;
525 /* Strip address and control fields */
527 && sc->sbuf[0] == PPP_ALLSTATIONS
528 && sc->sbuf[1] == PPP_UI)
531 /* Check for frame too big */
532 if (sc->slen - skip > sc->cfg.amru) {
533 sc->stats.asyncOverflows++;
537 /* OK, ship it out */
538 if ((n = m_devget(sc->sbuf + skip,
539 sc->slen - skip, 0, rcvif, NULL))) {
540 if (item) { /* sets NULL -> item */
541 NG_FWD_NEW_DATA(error, item,
544 NG_SEND_DATA_ONLY(error,
548 sc->stats.asyncFrames++;
550 sc->amode = MODE_NORMAL;
551 sc->fcs = PPP_INITFCS;
557 if (ch == PPP_ESCAPE) {
558 sc->amode = MODE_ESC;
564 sc->amode = MODE_NORMAL;
571 /* Add byte to frame */
572 if (sc->slen >= SYNC_BUF_SIZE(sc->cfg.amru)) {
573 sc->stats.asyncOverflows++;
574 sc->amode = MODE_HUNT;
577 sc->sbuf[sc->slen++] = ch;
578 sc->fcs = PPP_FCS(sc->fcs, ch);
591 * Taken from RFC 1171 Appendix B
593 static const u_int16_t fcstab[256] = {
594 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
595 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
596 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
597 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
598 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
599 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
600 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
601 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
602 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
603 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
604 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
605 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
606 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
607 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
608 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
609 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
610 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
611 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
612 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
613 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
614 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
615 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
616 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
617 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
618 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
619 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
620 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
621 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
622 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
623 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
624 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
625 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78