5 * Copyright (c) 1996-1999 Whistle Communications, Inc.
8 * Subject to the following obligations and disclaimer of warranty, use and
9 * redistribution of this software, in source or object code forms, with or
10 * without modifications are expressly permitted by Whistle Communications;
11 * provided, however, that:
12 * 1. Any and all reproductions of the source or object code must include the
13 * copyright notice above and the following disclaimer of warranties; and
14 * 2. No rights are granted, in any manner or form, to use Whistle
15 * Communications, Inc. trademarks, including the mark "WHISTLE
16 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as
17 * such appears in the above copyright notice or in the software.
19 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
20 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
21 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
22 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
24 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
25 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
26 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
27 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
28 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
29 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
30 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
31 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
37 * Author: Archie Cobbs <archie@freebsd.org>
39 * $FreeBSD: src/sys/netgraph/ng_async.c,v 1.6.2.5 2002/07/02 23:44:02 archie Exp $
40 * $DragonFly: src/sys/netgraph/async/ng_async.c,v 1.7 2008/01/05 14:02:39 swildner Exp $
41 * $Whistle: ng_async.c,v 1.17 1999/11/01 09:24:51 julian Exp $
45 * This node type implements a PPP style sync <-> async converter.
46 * See RFC 1661 for details of how asynchronous encoding works.
49 #include <sys/param.h>
50 #include <sys/systm.h>
51 #include <sys/kernel.h>
53 #include <sys/malloc.h>
54 #include <sys/errno.h>
56 #include <netgraph/ng_message.h>
57 #include <netgraph/netgraph.h>
59 #include <netgraph/ng_parse.h>
61 #include <net/ppp_layer/ppp_defs.h>
63 /* Async decode state */
68 /* Private data structure */
69 struct ng_async_private
{
70 node_p node
; /* Our node */
71 hook_p async
; /* Asynchronous side */
72 hook_p sync
; /* Synchronous side */
73 u_char amode
; /* Async hunt/esape mode */
74 u_int16_t fcs
; /* Decoded async FCS (so far) */
75 u_char
*abuf
; /* Buffer to encode sync into */
76 u_char
*sbuf
; /* Buffer to decode async into */
77 u_int slen
; /* Length of data in sbuf */
78 long lasttime
; /* Time of last async packet sent */
79 struct ng_async_cfg cfg
; /* Configuration */
80 struct ng_async_stat stats
; /* Statistics */
82 typedef struct ng_async_private
*sc_p
;
85 #define ASYNC_BUF_SIZE(smru) (2 * (smru) + 10)
86 #define SYNC_BUF_SIZE(amru) ((amru) + 10)
87 #define ERROUT(x) do { error = (x); goto done; } while (0)
89 /* Netgraph methods */
90 static ng_constructor_t nga_constructor
;
91 static ng_rcvdata_t nga_rcvdata
;
92 static ng_rcvmsg_t nga_rcvmsg
;
93 static ng_shutdown_t nga_shutdown
;
94 static ng_newhook_t nga_newhook
;
95 static ng_disconnect_t nga_disconnect
;
98 static int nga_rcv_sync(const sc_p sc
, struct mbuf
*m
, meta_p meta
);
99 static int nga_rcv_async(const sc_p sc
, struct mbuf
*m
, meta_p meta
);
101 /* Parse type for struct ng_async_cfg */
102 static const struct ng_parse_struct_field nga_config_type_fields
[]
103 = NG_ASYNC_CONFIG_TYPE_INFO
;
104 static const struct ng_parse_type nga_config_type
= {
105 &ng_parse_struct_type
,
106 &nga_config_type_fields
109 /* Parse type for struct ng_async_stat */
110 static const struct ng_parse_struct_field nga_stats_type_fields
[]
111 = NG_ASYNC_STATS_TYPE_INFO
;
112 static const struct ng_parse_type nga_stats_type
= {
113 &ng_parse_struct_type
,
114 &nga_stats_type_fields
117 /* List of commands and how to convert arguments to/from ASCII */
118 static const struct ng_cmdlist nga_cmdlist
[] = {
121 NGM_ASYNC_CMD_SET_CONFIG
,
128 NGM_ASYNC_CMD_GET_CONFIG
,
135 NGM_ASYNC_CMD_GET_STATS
,
142 NGM_ASYNC_CMD_CLR_STATS
,
150 /* Define the netgraph node type */
151 static struct ng_type typestruct
= {
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
*nodep
)
184 if ((error
= ng_make_node_common(&typestruct
, nodep
)))
186 MALLOC(sc
, sc_p
, sizeof(*sc
), M_NETGRAPH
, M_NOWAIT
| M_ZERO
);
189 sc
->amode
= MODE_HUNT
;
191 sc
->cfg
.amru
= NG_ASYNC_DEFAULT_MRU
;
192 sc
->cfg
.smru
= NG_ASYNC_DEFAULT_MRU
;
193 MALLOC(sc
->abuf
, u_char
*,
194 ASYNC_BUF_SIZE(sc
->cfg
.smru
), M_NETGRAPH
, M_NOWAIT
);
195 if (sc
->abuf
== NULL
)
197 MALLOC(sc
->sbuf
, u_char
*,
198 SYNC_BUF_SIZE(sc
->cfg
.amru
), M_NETGRAPH
, M_NOWAIT
);
199 if (sc
->sbuf
== NULL
) {
200 FREE(sc
->abuf
, M_NETGRAPH
);
202 FREE(sc
, M_NETGRAPH
);
205 (*nodep
)->private = sc
;
211 * Reserve a hook for a pending connection
214 nga_newhook(node_p node
, hook_p hook
, const char *name
)
216 const sc_p sc
= node
->private;
219 if (!strcmp(name
, NG_ASYNC_HOOK_ASYNC
))
221 else if (!strcmp(name
, NG_ASYNC_HOOK_SYNC
))
232 * Receive incoming data
235 nga_rcvdata(hook_p hook
, struct mbuf
*m
, meta_p meta
)
237 const sc_p sc
= hook
->node
->private;
239 if (hook
== sc
->sync
)
240 return (nga_rcv_sync(sc
, m
, meta
));
241 if (hook
== sc
->async
)
242 return (nga_rcv_async(sc
, m
, meta
));
247 * Receive incoming control message
250 nga_rcvmsg(node_p node
, struct ng_mesg
*msg
,
251 const char *rtn
, struct ng_mesg
**rptr
)
253 const sc_p sc
= (sc_p
) node
->private;
254 struct ng_mesg
*resp
= NULL
;
257 switch (msg
->header
.typecookie
) {
258 case NGM_ASYNC_COOKIE
:
259 switch (msg
->header
.cmd
) {
260 case NGM_ASYNC_CMD_GET_STATS
:
261 NG_MKRESPONSE(resp
, msg
, sizeof(sc
->stats
), M_NOWAIT
);
264 *((struct ng_async_stat
*) resp
->data
) = sc
->stats
;
266 case NGM_ASYNC_CMD_CLR_STATS
:
267 bzero(&sc
->stats
, sizeof(sc
->stats
));
269 case NGM_ASYNC_CMD_SET_CONFIG
:
271 struct ng_async_cfg
*const cfg
=
272 (struct ng_async_cfg
*) msg
->data
;
275 if (msg
->header
.arglen
!= sizeof(*cfg
))
277 if (cfg
->amru
< NG_ASYNC_MIN_MRU
278 || cfg
->amru
> NG_ASYNC_MAX_MRU
279 || cfg
->smru
< NG_ASYNC_MIN_MRU
280 || cfg
->smru
> NG_ASYNC_MAX_MRU
)
282 cfg
->enabled
= !!cfg
->enabled
; /* normalize */
283 if (cfg
->smru
> sc
->cfg
.smru
) { /* reallocate buffer */
284 MALLOC(buf
, u_char
*, ASYNC_BUF_SIZE(cfg
->smru
),
285 M_NETGRAPH
, M_NOWAIT
);
288 FREE(sc
->abuf
, M_NETGRAPH
);
291 if (cfg
->amru
> sc
->cfg
.amru
) { /* reallocate buffer */
292 MALLOC(buf
, u_char
*, SYNC_BUF_SIZE(cfg
->amru
),
293 M_NETGRAPH
, M_NOWAIT
);
296 FREE(sc
->sbuf
, M_NETGRAPH
);
298 sc
->amode
= MODE_HUNT
;
302 sc
->amode
= MODE_HUNT
;
308 case NGM_ASYNC_CMD_GET_CONFIG
:
309 NG_MKRESPONSE(resp
, msg
, sizeof(sc
->cfg
), M_NOWAIT
);
312 *((struct ng_async_cfg
*) resp
->data
) = sc
->cfg
;
324 FREE(resp
, M_NETGRAPH
);
327 FREE(msg
, M_NETGRAPH
);
335 nga_shutdown(node_p node
)
337 const sc_p sc
= node
->private;
341 FREE(sc
->abuf
, M_NETGRAPH
);
342 FREE(sc
->sbuf
, M_NETGRAPH
);
343 bzero(sc
, sizeof(*sc
));
344 FREE(sc
, M_NETGRAPH
);
345 node
->private = NULL
;
351 * Lose a hook. When both hooks go away, we disappear.
354 nga_disconnect(hook_p hook
)
356 const sc_p sc
= hook
->node
->private;
359 if (hook
== sc
->async
)
361 else if (hook
== sc
->sync
)
366 panic("%s2", __func__
);
368 bzero(&sc
->stats
, sizeof(sc
->stats
));
370 if (hook
->node
->numhooks
== 0)
371 ng_rmnode(hook
->node
);
375 /******************************************************************
376 INTERNAL HELPER STUFF
377 ******************************************************************/
380 * Encode a byte into the async buffer
382 static __inline__
void
383 nga_async_add(const sc_p sc
, u_int16_t
*fcs
, u_int32_t accm
, int *len
, u_char x
)
385 *fcs
= PPP_FCS(*fcs
, x
);
386 if ((x
< 32 && ((1 << x
) & accm
))
388 || (x
== PPP_FLAG
)) {
389 sc
->abuf
[(*len
)++] = PPP_ESCAPE
;
392 sc
->abuf
[(*len
)++] = x
;
396 * Receive incoming synchronous data.
399 nga_rcv_sync(const sc_p sc
, struct mbuf
*m
, meta_p meta
)
401 struct ifnet
*const rcvif
= m
->m_pkthdr
.rcvif
;
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_SEND_DATA(error
, sc
->async
, m
, meta
);
415 /* Get ACCM; special case LCP frames, which use full ACCM */
417 if (m
->m_pkthdr
.len
>= 4) {
418 static const u_char lcphdr
[4] = {
421 (u_char
)(PPP_LCP
>> 8),
422 (u_char
)(PPP_LCP
& 0xff)
426 m_copydata(m
, 0, 4, (caddr_t
)buf
);
427 if (bcmp(buf
, &lcphdr
, 4) == 0)
431 /* Check for overflow */
432 if (m
->m_pkthdr
.len
> sc
->cfg
.smru
) {
433 sc
->stats
.syncOverflows
++;
434 NG_FREE_DATA(m
, meta
);
439 sc
->stats
.syncFrames
++;
440 sc
->stats
.syncOctets
+= m
->m_pkthdr
.len
;
442 /* Initialize async encoded version of input mbuf */
446 /* Add beginning sync flag if it's been long enough to need one */
448 if (time
.tv_sec
>= sc
->lasttime
+ 1) {
449 sc
->abuf
[alen
++] = PPP_FLAG
;
450 sc
->lasttime
= time
.tv_sec
;
453 /* Add packet payload */
455 while (m
->m_len
> 0) {
456 ADD_BYTE(*mtod(m
, u_char
*));
463 /* Add checksum and final sync flag */
465 ADD_BYTE(~fcs0
& 0xff);
466 ADD_BYTE(~fcs0
>> 8);
467 sc
->abuf
[alen
++] = PPP_FLAG
;
469 /* Put frame in an mbuf and ship it off */
470 if (!(m
= m_devget(sc
->abuf
, alen
, 0, rcvif
, NULL
))) {
474 NG_SEND_DATA(error
, sc
->async
, m
, meta
);
479 * Receive incoming asynchronous data
480 * XXX Technically, we should strip out incoming characters
481 * that are in our ACCM. Not sure if this is good or not.
484 nga_rcv_async(const sc_p sc
, struct mbuf
* m
, meta_p meta
)
486 struct ifnet
*const rcvif
= m
->m_pkthdr
.rcvif
;
489 if (!sc
->cfg
.enabled
) {
490 NG_SEND_DATA(error
, sc
->sync
, m
, meta
);
497 for (; m
->m_len
> 0; m
->m_data
++, m
->m_len
--) {
498 u_char ch
= *mtod(m
, u_char
*);
500 sc
->stats
.asyncOctets
++;
501 if (ch
== PPP_FLAG
) { /* Flag overrides everything */
504 /* Check for runts */
507 sc
->stats
.asyncRunts
++;
512 if (sc
->fcs
!= PPP_GOODFCS
) {
513 sc
->stats
.asyncBadCheckSums
++;
518 /* Strip address and control fields */
520 && sc
->sbuf
[0] == PPP_ALLSTATIONS
521 && sc
->sbuf
[1] == PPP_UI
)
524 /* Check for frame too big */
525 if (sc
->slen
- skip
> sc
->cfg
.amru
) {
526 sc
->stats
.asyncOverflows
++;
530 /* OK, ship it out */
531 if ((n
= m_devget(sc
->sbuf
+ skip
,
532 sc
->slen
- skip
, 0, rcvif
, NULL
)))
533 NG_SEND_DATA(error
, sc
->sync
, n
, meta
);
534 sc
->stats
.asyncFrames
++;
536 sc
->amode
= MODE_NORMAL
;
537 sc
->fcs
= PPP_INITFCS
;
543 if (ch
== PPP_ESCAPE
) {
544 sc
->amode
= MODE_ESC
;
550 sc
->amode
= MODE_NORMAL
;
557 /* Add byte to frame */
558 if (sc
->slen
>= SYNC_BUF_SIZE(sc
->cfg
.amru
)) {
559 sc
->stats
.asyncOverflows
++;
560 sc
->amode
= MODE_HUNT
;
563 sc
->sbuf
[sc
->slen
++] = ch
;
564 sc
->fcs
= PPP_FCS(sc
->fcs
, ch
);
575 * Taken from RFC 1171 Appendix B
577 static const u_int16_t fcstab
[256] = {
578 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
579 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
580 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
581 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
582 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
583 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
584 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
585 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
586 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
587 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
588 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
589 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
590 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
591 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
592 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
593 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
594 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
595 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
596 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
597 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
598 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
599 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
600 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
601 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
602 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
603 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
604 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
605 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
606 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
607 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
608 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
609 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78