1 /* 2 * ng_async.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 * $FreeBSD: src/sys/netgraph/ng_async.c,v 1.22 2005/01/07 01:45:39 imp Exp $ 41 * $Whistle: ng_async.c,v 1.17 1999/11/01 09:24:51 julian Exp $ 42 */ 43 44 /* 45 * This node type implements a PPP style sync <-> async converter. 46 * See RFC 1661 for details of how asynchronous encoding works. 47 */ 48 49 #include <sys/param.h> 50 #include <sys/systm.h> 51 #include <sys/kernel.h> 52 #include <sys/mbuf.h> 53 #include <sys/malloc.h> 54 #include <sys/errno.h> 55 56 #include <netgraph7/ng_message.h> 57 #include <netgraph7/netgraph.h> 58 #include "ng_async.h" 59 #include <netgraph7/ng_parse.h> 60 61 #include <net/ppp_layer/ppp_defs.h> 62 63 #ifdef NG_SEPARATE_MALLOC 64 MALLOC_DEFINE(M_NETGRAPH_ASYNC, "netgraph_async", "netgraph async node "); 65 #else 66 #define M_NETGRAPH_ASYNC M_NETGRAPH 67 #endif 68 69 70 /* Async decode state */ 71 #define MODE_HUNT 0 72 #define MODE_NORMAL 1 73 #define MODE_ESC 2 74 75 /* Private data structure */ 76 struct ng_async_private { 77 node_p node; /* Our node */ 78 hook_p async; /* Asynchronous side */ 79 hook_p sync; /* Synchronous side */ 80 u_char amode; /* Async hunt/esape mode */ 81 u_int16_t fcs; /* Decoded async FCS (so far) */ 82 u_char *abuf; /* Buffer to encode sync into */ 83 u_char *sbuf; /* Buffer to decode async into */ 84 u_int slen; /* Length of data in sbuf */ 85 long lasttime; /* Time of last async packet sent */ 86 struct ng_async_cfg cfg; /* Configuration */ 87 struct ng_async_stat stats; /* Statistics */ 88 }; 89 typedef struct ng_async_private *sc_p; 90 91 /* Useful macros */ 92 #define ASYNC_BUF_SIZE(smru) (2 * (smru) + 10) 93 #define SYNC_BUF_SIZE(amru) ((amru) + 10) 94 #define ERROUT(x) do { error = (x); goto done; } while (0) 95 96 /* Netgraph methods */ 97 static ng_constructor_t nga_constructor; 98 static ng_rcvdata_t nga_rcvdata; 99 static ng_rcvmsg_t nga_rcvmsg; 100 static ng_shutdown_t nga_shutdown; 101 static ng_newhook_t nga_newhook; 102 static ng_disconnect_t nga_disconnect; 103 104 /* Helper stuff */ 105 static int nga_rcv_sync(const sc_p sc, item_p item); 106 static int nga_rcv_async(const sc_p sc, item_p item); 107 108 /* Parse type for struct ng_async_cfg */ 109 static const struct ng_parse_struct_field nga_config_type_fields[] 110 = NG_ASYNC_CONFIG_TYPE_INFO; 111 static const struct ng_parse_type nga_config_type = { 112 &ng_parse_struct_type, 113 &nga_config_type_fields 114 }; 115 116 /* Parse type for struct ng_async_stat */ 117 static const struct ng_parse_struct_field nga_stats_type_fields[] 118 = NG_ASYNC_STATS_TYPE_INFO; 119 static const struct ng_parse_type nga_stats_type = { 120 &ng_parse_struct_type, 121 &nga_stats_type_fields 122 }; 123 124 /* List of commands and how to convert arguments to/from ASCII */ 125 static const struct ng_cmdlist nga_cmdlist[] = { 126 { 127 NGM_ASYNC_COOKIE, 128 NGM_ASYNC_CMD_SET_CONFIG, 129 "setconfig", 130 &nga_config_type, 131 NULL 132 }, 133 { 134 NGM_ASYNC_COOKIE, 135 NGM_ASYNC_CMD_GET_CONFIG, 136 "getconfig", 137 NULL, 138 &nga_config_type 139 }, 140 { 141 NGM_ASYNC_COOKIE, 142 NGM_ASYNC_CMD_GET_STATS, 143 "getstats", 144 NULL, 145 &nga_stats_type 146 }, 147 { 148 NGM_ASYNC_COOKIE, 149 NGM_ASYNC_CMD_CLR_STATS, 150 "clrstats", 151 &nga_stats_type, 152 NULL 153 }, 154 { 0 } 155 }; 156 157 /* Define the netgraph node type */ 158 static struct ng_type typestruct = { 159 .version = NG_ABI_VERSION, 160 .name = NG_ASYNC_NODE_TYPE, 161 .constructor = nga_constructor, 162 .rcvmsg = nga_rcvmsg, 163 .shutdown = nga_shutdown, 164 .newhook = nga_newhook, 165 .rcvdata = nga_rcvdata, 166 .disconnect = nga_disconnect, 167 .cmdlist = nga_cmdlist 168 }; 169 NETGRAPH_INIT(async, &typestruct); 170 171 /* 172 * CRC table 173 * 174 * Taken from RFC 1171 Appendix B 175 */ 176 static const u_int16_t fcstab[256] = { 177 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 178 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 179 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 180 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 181 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 182 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 183 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 184 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 185 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 186 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 187 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 188 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 189 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 190 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 191 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 192 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 193 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 194 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 195 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 196 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 197 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 198 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 199 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 200 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 201 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 202 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 203 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 204 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 205 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 206 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 207 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 208 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 209 }; 210 211 /****************************************************************** 212 NETGRAPH NODE METHODS 213 ******************************************************************/ 214 215 /* 216 * Initialize a new node 217 */ 218 static int 219 nga_constructor(node_p node) 220 { 221 sc_p sc; 222 223 sc = kmalloc(sizeof(*sc), M_NETGRAPH_ASYNC, 224 M_WAITOK | M_NULLOK | M_ZERO); 225 if (sc == NULL) 226 return (ENOMEM); 227 sc->amode = MODE_HUNT; 228 sc->cfg.accm = ~0; 229 sc->cfg.amru = NG_ASYNC_DEFAULT_MRU; 230 sc->cfg.smru = NG_ASYNC_DEFAULT_MRU; 231 sc->abuf = kmalloc(ASYNC_BUF_SIZE(sc->cfg.smru), M_NETGRAPH_ASYNC, 232 M_WAITOK | M_NULLOK); 233 if (sc->abuf == NULL) 234 goto fail; 235 sc->sbuf = kmalloc(SYNC_BUF_SIZE(sc->cfg.amru), M_NETGRAPH_ASYNC, 236 M_WAITOK | M_NULLOK); 237 if (sc->sbuf == NULL) { 238 kfree(sc->abuf, M_NETGRAPH_ASYNC); 239 fail: 240 kfree(sc, M_NETGRAPH_ASYNC); 241 return (ENOMEM); 242 } 243 NG_NODE_SET_PRIVATE(node, sc); 244 sc->node = node; 245 return (0); 246 } 247 248 /* 249 * Reserve a hook for a pending connection 250 */ 251 static int 252 nga_newhook(node_p node, hook_p hook, const char *name) 253 { 254 const sc_p sc = NG_NODE_PRIVATE(node); 255 hook_p *hookp; 256 257 if (!strcmp(name, NG_ASYNC_HOOK_ASYNC)) { 258 /* 259 * We use a static buffer here so only one packet 260 * at a time can be allowed to travel in this direction. 261 * Force Writer semantics. 262 */ 263 NG_HOOK_FORCE_WRITER(hook); 264 hookp = &sc->async; 265 } else if (!strcmp(name, NG_ASYNC_HOOK_SYNC)) { 266 /* 267 * We use a static state here so only one packet 268 * at a time can be allowed to travel in this direction. 269 * Force Writer semantics. 270 * Since we set this for both directions 271 * we might as well set it for the whole node 272 * bit I haven;t done that (yet). 273 */ 274 NG_HOOK_FORCE_WRITER(hook); 275 hookp = &sc->sync; 276 } else { 277 return (EINVAL); 278 } 279 if (*hookp) /* actually can't happen I think [JRE] */ 280 return (EISCONN); 281 *hookp = hook; 282 return (0); 283 } 284 285 /* 286 * Receive incoming data 287 */ 288 static int 289 nga_rcvdata(hook_p hook, item_p item) 290 { 291 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 292 293 if (hook == sc->sync) 294 return (nga_rcv_sync(sc, item)); 295 if (hook == sc->async) 296 return (nga_rcv_async(sc, item)); 297 panic(__func__); 298 } 299 300 /* 301 * Receive incoming control message 302 */ 303 static int 304 nga_rcvmsg(node_p node, item_p item, hook_p lasthook) 305 { 306 const sc_p sc = NG_NODE_PRIVATE(node); 307 struct ng_mesg *resp = NULL; 308 int error = 0; 309 struct ng_mesg *msg; 310 311 NGI_GET_MSG(item, msg); 312 switch (msg->header.typecookie) { 313 case NGM_ASYNC_COOKIE: 314 switch (msg->header.cmd) { 315 case NGM_ASYNC_CMD_GET_STATS: 316 NG_MKRESPONSE(resp, msg, sizeof(sc->stats), M_WAITOK | M_NULLOK); 317 if (resp == NULL) 318 ERROUT(ENOMEM); 319 *((struct ng_async_stat *) resp->data) = sc->stats; 320 break; 321 case NGM_ASYNC_CMD_CLR_STATS: 322 bzero(&sc->stats, sizeof(sc->stats)); 323 break; 324 case NGM_ASYNC_CMD_SET_CONFIG: 325 { 326 struct ng_async_cfg *const cfg = 327 (struct ng_async_cfg *) msg->data; 328 u_char *buf; 329 330 if (msg->header.arglen != sizeof(*cfg)) 331 ERROUT(EINVAL); 332 if (cfg->amru < NG_ASYNC_MIN_MRU 333 || cfg->amru > NG_ASYNC_MAX_MRU 334 || cfg->smru < NG_ASYNC_MIN_MRU 335 || cfg->smru > NG_ASYNC_MAX_MRU) 336 ERROUT(EINVAL); 337 cfg->enabled = !!cfg->enabled; /* normalize */ 338 if (cfg->smru > sc->cfg.smru) { /* reallocate buffer */ 339 buf = kmalloc(ASYNC_BUF_SIZE(cfg->smru), 340 M_NETGRAPH_ASYNC, 341 M_WAITOK | M_NULLOK); 342 if (!buf) 343 ERROUT(ENOMEM); 344 kfree(sc->abuf, M_NETGRAPH_ASYNC); 345 sc->abuf = buf; 346 } 347 if (cfg->amru > sc->cfg.amru) { /* reallocate buffer */ 348 buf = kmalloc(SYNC_BUF_SIZE(cfg->amru), 349 M_NETGRAPH_ASYNC, 350 M_WAITOK | M_NULLOK); 351 if (!buf) 352 ERROUT(ENOMEM); 353 kfree(sc->sbuf, M_NETGRAPH_ASYNC); 354 sc->sbuf = buf; 355 sc->amode = MODE_HUNT; 356 sc->slen = 0; 357 } 358 if (!cfg->enabled) { 359 sc->amode = MODE_HUNT; 360 sc->slen = 0; 361 } 362 sc->cfg = *cfg; 363 break; 364 } 365 case NGM_ASYNC_CMD_GET_CONFIG: 366 NG_MKRESPONSE(resp, msg, sizeof(sc->cfg), M_WAITOK | M_NULLOK); 367 if (!resp) 368 ERROUT(ENOMEM); 369 *((struct ng_async_cfg *) resp->data) = sc->cfg; 370 break; 371 default: 372 ERROUT(EINVAL); 373 } 374 break; 375 default: 376 ERROUT(EINVAL); 377 } 378 done: 379 NG_RESPOND_MSG(error, node, item, resp); 380 NG_FREE_MSG(msg); 381 return (error); 382 } 383 384 /* 385 * Shutdown this node 386 */ 387 static int 388 nga_shutdown(node_p node) 389 { 390 const sc_p sc = NG_NODE_PRIVATE(node); 391 392 kfree(sc->abuf, M_NETGRAPH_ASYNC); 393 kfree(sc->sbuf, M_NETGRAPH_ASYNC); 394 bzero(sc, sizeof(*sc)); 395 kfree(sc, M_NETGRAPH_ASYNC); 396 NG_NODE_SET_PRIVATE(node, NULL); 397 NG_NODE_UNREF(node); 398 return (0); 399 } 400 401 /* 402 * Lose a hook. When both hooks go away, we disappear. 403 */ 404 static int 405 nga_disconnect(hook_p hook) 406 { 407 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 408 hook_p *hookp; 409 410 if (hook == sc->async) 411 hookp = &sc->async; 412 else if (hook == sc->sync) 413 hookp = &sc->sync; 414 else 415 panic(__func__); 416 if (!*hookp) 417 panic("%s 2", __func__); 418 *hookp = NULL; 419 bzero(&sc->stats, sizeof(sc->stats)); 420 sc->lasttime = 0; 421 if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) 422 && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook)))) 423 ng_rmnode_self(NG_HOOK_NODE(hook)); 424 return (0); 425 } 426 427 /****************************************************************** 428 INTERNAL HELPER STUFF 429 ******************************************************************/ 430 431 /* 432 * Encode a byte into the async buffer 433 */ 434 static __inline void 435 nga_async_add(const sc_p sc, u_int16_t *fcs, u_int32_t accm, int *len, u_char x) 436 { 437 *fcs = PPP_FCS(*fcs, x); 438 if ((x < 32 && ((1 << x) & accm)) 439 || (x == PPP_ESCAPE) 440 || (x == PPP_FLAG)) { 441 sc->abuf[(*len)++] = PPP_ESCAPE; 442 x ^= PPP_TRANS; 443 } 444 sc->abuf[(*len)++] = x; 445 } 446 447 /* 448 * Receive incoming synchronous data. 449 */ 450 static int 451 nga_rcv_sync(const sc_p sc, item_p item) 452 { 453 struct ifnet *rcvif; 454 int alen, error = 0; 455 struct timeval time; 456 u_int16_t fcs, fcs0; 457 u_int32_t accm; 458 struct mbuf *m; 459 460 461 #define ADD_BYTE(x) nga_async_add(sc, &fcs, accm, &alen, (x)) 462 463 /* Check for bypass mode */ 464 if (!sc->cfg.enabled) { 465 NG_FWD_ITEM_HOOK(error, item, sc->async ); 466 return (error); 467 } 468 NGI_GET_M(item, m); 469 470 rcvif = m->m_pkthdr.rcvif; 471 472 /* Get ACCM; special case LCP frames, which use full ACCM */ 473 accm = sc->cfg.accm; 474 if (m->m_pkthdr.len >= 4) { 475 static const u_char lcphdr[4] = { 476 PPP_ALLSTATIONS, 477 PPP_UI, 478 (u_char)(PPP_LCP >> 8), 479 (u_char)(PPP_LCP & 0xff) 480 }; 481 u_char buf[4]; 482 483 m_copydata(m, 0, 4, buf); 484 if (bcmp(buf, &lcphdr, 4) == 0) 485 accm = ~0; 486 } 487 488 /* Check for overflow */ 489 if (m->m_pkthdr.len > sc->cfg.smru) { 490 sc->stats.syncOverflows++; 491 NG_FREE_M(m); 492 NG_FREE_ITEM(item); 493 return (EMSGSIZE); 494 } 495 496 /* Update stats */ 497 sc->stats.syncFrames++; 498 sc->stats.syncOctets += m->m_pkthdr.len; 499 500 /* Initialize async encoded version of input mbuf */ 501 alen = 0; 502 fcs = PPP_INITFCS; 503 504 /* Add beginning sync flag if it's been long enough to need one */ 505 getmicrotime(&time); 506 if (time.tv_sec >= sc->lasttime + 1) { 507 sc->abuf[alen++] = PPP_FLAG; 508 sc->lasttime = time.tv_sec; 509 } 510 511 /* Add packet payload */ 512 while (m != NULL) { 513 while (m->m_len > 0) { 514 ADD_BYTE(*mtod(m, u_char *)); 515 m->m_data++; 516 m->m_len--; 517 } 518 m = m_free(m); 519 } 520 521 /* Add checksum and final sync flag */ 522 fcs0 = fcs; 523 ADD_BYTE(~fcs0 & 0xff); 524 ADD_BYTE(~fcs0 >> 8); 525 sc->abuf[alen++] = PPP_FLAG; 526 527 /* Put frame in an mbuf and ship it off */ 528 if (!(m = m_devget(sc->abuf, alen, 0, rcvif))) { 529 NG_FREE_ITEM(item); 530 error = ENOBUFS; 531 } else { 532 NG_FWD_NEW_DATA(error, item, sc->async, m); 533 } 534 return (error); 535 } 536 537 /* 538 * Receive incoming asynchronous data 539 * XXX Technically, we should strip out incoming characters 540 * that are in our ACCM. Not sure if this is good or not. 541 */ 542 static int 543 nga_rcv_async(const sc_p sc, item_p item) 544 { 545 struct ifnet *rcvif; 546 int error; 547 struct mbuf *m; 548 549 if (!sc->cfg.enabled) { 550 NG_FWD_ITEM_HOOK(error, item, sc->sync); 551 return (error); 552 } 553 NGI_GET_M(item, m); 554 rcvif = m->m_pkthdr.rcvif; 555 while (m) { 556 struct mbuf *n; 557 558 for (; m->m_len > 0; m->m_data++, m->m_len--) { 559 u_char ch = *mtod(m, u_char *); 560 561 sc->stats.asyncOctets++; 562 if (ch == PPP_FLAG) { /* Flag overrides everything */ 563 int skip = 0; 564 565 /* Check for runts */ 566 if (sc->slen < 2) { 567 if (sc->slen > 0) 568 sc->stats.asyncRunts++; 569 goto reset; 570 } 571 572 /* Verify CRC */ 573 if (sc->fcs != PPP_GOODFCS) { 574 sc->stats.asyncBadCheckSums++; 575 goto reset; 576 } 577 sc->slen -= 2; 578 579 /* Strip address and control fields */ 580 if (sc->slen >= 2 581 && sc->sbuf[0] == PPP_ALLSTATIONS 582 && sc->sbuf[1] == PPP_UI) 583 skip = 2; 584 585 /* Check for frame too big */ 586 if (sc->slen - skip > sc->cfg.amru) { 587 sc->stats.asyncOverflows++; 588 goto reset; 589 } 590 591 /* OK, ship it out */ 592 if ((n = m_devget(sc->sbuf + skip, 593 sc->slen - skip, 0, rcvif))) { 594 if (item) { /* sets NULL -> item */ 595 NG_FWD_NEW_DATA(error, item, 596 sc->sync, n); 597 } else { 598 NG_SEND_DATA_ONLY(error, 599 sc->sync ,n); 600 } 601 } 602 sc->stats.asyncFrames++; 603 reset: 604 sc->amode = MODE_NORMAL; 605 sc->fcs = PPP_INITFCS; 606 sc->slen = 0; 607 continue; 608 } 609 switch (sc->amode) { 610 case MODE_NORMAL: 611 if (ch == PPP_ESCAPE) { 612 sc->amode = MODE_ESC; 613 continue; 614 } 615 break; 616 case MODE_ESC: 617 ch ^= PPP_TRANS; 618 sc->amode = MODE_NORMAL; 619 break; 620 case MODE_HUNT: 621 default: 622 continue; 623 } 624 625 /* Add byte to frame */ 626 if (sc->slen >= SYNC_BUF_SIZE(sc->cfg.amru)) { 627 sc->stats.asyncOverflows++; 628 sc->amode = MODE_HUNT; 629 sc->slen = 0; 630 } else { 631 sc->sbuf[sc->slen++] = ch; 632 sc->fcs = PPP_FCS(sc->fcs, ch); 633 } 634 } 635 m = m_free(m); 636 } 637 if (item) 638 NG_FREE_ITEM(item); 639 return (0); 640 } 641