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