sys/netgraph/ng_async.c

   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  * $Whistle: ng_async.c,v 1.17 1999/11/01 09:24:51 julian Exp $
  40  */
  41
  42 /*
  43  * This node type implements a PPP style sync <-> async converter.
  44  * See RFC 1661 for details of how asynchronous encoding works.
  45  */
  46
  47 #include <sys/param.h>
  48 #include <sys/systm.h>
  49 #include <sys/kernel.h>
  50 #include <sys/mbuf.h>
  51 #include <sys/malloc.h>
  52 #include <sys/errno.h>
  53
  54 #include <netgraph/ng_message.h>
  55 #include <netgraph/netgraph.h>
  56 #include <netgraph/ng_async.h>
  57 #include <netgraph/ng_parse.h>
  58
  59 #include <net/ppp_defs.h>
  60
  61 #ifdef NG_SEPARATE_MALLOC
  62 static MALLOC_DEFINE(M_NETGRAPH_ASYNC, "netgraph_async", "netgraph async node");
  63 #else
  64 #define M_NETGRAPH_ASYNC M_NETGRAPH
  65 #endif
  66
  67 /* Async decode state */
  68 #define MODE_HUNT       0
  69 #define MODE_NORMAL     1
  70 #define MODE_ESC        2
  71
  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 */
  85 };
  86 typedef struct ng_async_private *sc_p;
  87
  88 /* Useful macros */
  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)
  92
  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;
 100
 101 /* Helper stuff */
 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);
 104
 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
 111 };
 112
 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
 119 };
 120
 121 /* List of commands and how to convert arguments to/from ASCII */
 122 static const struct ng_cmdlist nga_cmdlist[] = {
 123         {
 124           NGM_ASYNC_COOKIE,
 125           NGM_ASYNC_CMD_SET_CONFIG,
 126           "setconfig",
 127           &nga_config_type,
 128           NULL
 129         },
 130         {
 131           NGM_ASYNC_COOKIE,
 132           NGM_ASYNC_CMD_GET_CONFIG,
 133           "getconfig",
 134           NULL,
 135           &nga_config_type
 136         },
 137         {
 138           NGM_ASYNC_COOKIE,
 139           NGM_ASYNC_CMD_GET_STATS,
 140           "getstats",
 141           NULL,
 142           &nga_stats_type
 143         },
 144         {
 145           NGM_ASYNC_COOKIE,
 146           NGM_ASYNC_CMD_CLR_STATS,
 147           "clrstats",
 148           &nga_stats_type,
 149           NULL
 150         },
 151         { 0 }
 152 };
 153
 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
 165 };
 166 NETGRAPH_INIT(async, &typestruct);
 167
 168 /* CRC table */
 169 static const u_int16_t fcstab[];
 170
 171 /******************************************************************
 172                     NETGRAPH NODE METHODS
 173 ******************************************************************/
 174
 175 /*
 176  * Initialize a new node
 177  */
 178 static int
 179 nga_constructor(node_p node)
 180 {
 181         sc_p sc;
 182
 183         sc = malloc(sizeof(*sc), M_NETGRAPH_ASYNC, M_WAITOK | M_ZERO);
 184         sc->amode = MODE_HUNT;
 185         sc->cfg.accm = ~0;
 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);
 193         sc->node = node;
 194         return (0);
 195 }
 196
 197 /*
 198  * Reserve a hook for a pending connection
 199  */
 200 static int
 201 nga_newhook(node_p node, hook_p hook, const char *name)
 202 {
 203         const sc_p sc = NG_NODE_PRIVATE(node);
 204         hook_p *hookp;
 205
 206         if (!strcmp(name, NG_ASYNC_HOOK_ASYNC)) {
 207                 /*
 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.
 211                  */
 212                 NG_HOOK_FORCE_WRITER(hook);
 213                 hookp = &sc->async;
 214         } else if (!strcmp(name, NG_ASYNC_HOOK_SYNC)) {
 215                 /*
 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).
 222                  */
 223                 NG_HOOK_FORCE_WRITER(hook);
 224                 hookp = &sc->sync;
 225         } else {
 226                 return (EINVAL);
 227         }
 228         if (*hookp) /* actually can't happen I think [JRE] */
 229                 return (EISCONN);
 230         *hookp = hook;
 231         return (0);
 232 }
 233
 234 /*
 235  * Receive incoming data
 236  */
 237 static int
 238 nga_rcvdata(hook_p hook, item_p item)
 239 {
 240         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 241
 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__);
 247 }
 248
 249 /*
 250  * Receive incoming control message
 251  */
 252 static int
 253 nga_rcvmsg(node_p node, item_p item, hook_p lasthook)
 254 {
 255         const sc_p sc = NG_NODE_PRIVATE(node);
 256         struct ng_mesg *resp = NULL;
 257         int error = 0;
 258         struct ng_mesg *msg;
 259
 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);
 266                         if (resp == NULL)
 267                                 ERROUT(ENOMEM);
 268                         *((struct ng_async_stat *) resp->data) = sc->stats;
 269                         break;
 270                 case NGM_ASYNC_CMD_CLR_STATS:
 271                         bzero(&sc->stats, sizeof(sc->stats));
 272                         break;
 273                 case NGM_ASYNC_CMD_SET_CONFIG:
 274                     {
 275                         struct ng_async_cfg *const cfg =
 276                                 (struct ng_async_cfg *) msg->data;
 277                         u_char *buf;
 278
 279                         if (msg->header.arglen != sizeof(*cfg))
 280                                 ERROUT(EINVAL);
 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)
 285                                 ERROUT(EINVAL);
 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);
 290                                 if (!buf)
 291                                         ERROUT(ENOMEM);
 292                                 free(sc->abuf, M_NETGRAPH_ASYNC);
 293                                 sc->abuf = buf;
 294                         }
 295                         if (cfg->amru > sc->cfg.amru) { /* reallocate buffer */
 296                                 buf = malloc(SYNC_BUF_SIZE(cfg->amru),
 297                                     M_NETGRAPH_ASYNC, M_NOWAIT);
 298                                 if (!buf)
 299                                         ERROUT(ENOMEM);
 300                                 free(sc->sbuf, M_NETGRAPH_ASYNC);
 301                                 sc->sbuf = buf;
 302                                 sc->amode = MODE_HUNT;
 303                                 sc->slen = 0;
 304                         }
 305                         if (!cfg->enabled) {
 306                                 sc->amode = MODE_HUNT;
 307                                 sc->slen = 0;
 308                         }
 309                         sc->cfg = *cfg;
 310                         break;
 311                     }
 312                 case NGM_ASYNC_CMD_GET_CONFIG:
 313                         NG_MKRESPONSE(resp, msg, sizeof(sc->cfg), M_NOWAIT);
 314                         if (!resp)
 315                                 ERROUT(ENOMEM);
 316                         *((struct ng_async_cfg *) resp->data) = sc->cfg;
 317                         break;
 318                 default:
 319                         ERROUT(EINVAL);
 320                 }
 321                 break;
 322         default:
 323                 ERROUT(EINVAL);
 324         }
 325 done:
 326         NG_RESPOND_MSG(error, node, item, resp);
 327         NG_FREE_MSG(msg);
 328         return (error);
 329 }
 330
 331 /*
 332  * Shutdown this node
 333  */
 334 static int
 335 nga_shutdown(node_p node)
 336 {
 337         const sc_p sc = NG_NODE_PRIVATE(node);
 338
 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);
 344         NG_NODE_UNREF(node);
 345         return (0);
 346 }
 347
 348 /*
 349  * Lose a hook. When both hooks go away, we disappear.
 350  */
 351 static int
 352 nga_disconnect(hook_p hook)
 353 {
 354         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 355         hook_p *hookp;
 356
 357         if (hook == sc->async)
 358                 hookp = &sc->async;
 359         else if (hook == sc->sync)
 360                 hookp = &sc->sync;
 361         else
 362                 panic("%s", __func__);
 363         if (!*hookp)
 364                 panic("%s 2", __func__);
 365         *hookp = NULL;
 366         bzero(&sc->stats, sizeof(sc->stats));
 367         sc->lasttime = 0;
 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));
 371         return (0);
 372 }
 373
 374 /******************************************************************
 375                     INTERNAL HELPER STUFF
 376 ******************************************************************/
 377
 378 /*
 379  * Encode a byte into the async buffer
 380  */
 381 static __inline void
 382 nga_async_add(const sc_p sc, u_int16_t *fcs, u_int32_t accm, int *len, u_char x)
 383 {
 384         *fcs = PPP_FCS(*fcs, x);
 385         if ((x < 32 && ((1 << x) & accm))
 386             || (x == PPP_ESCAPE)
 387             || (x == PPP_FLAG)) {
 388                 sc->abuf[(*len)++] = PPP_ESCAPE;
 389                 x ^= PPP_TRANS;
 390         }
 391         sc->abuf[(*len)++] = x;
 392 }
 393
 394 /*
 395  * Receive incoming synchronous data.
 396  */
 397 static int
 398 nga_rcv_sync(const sc_p sc, item_p item)
 399 {
 400         struct ifnet *rcvif;
 401         int alen, error = 0;
 402         struct timeval time;
 403         u_int16_t fcs, fcs0;
 404         u_int32_t accm;
 405         struct mbuf *m;
 406
 407 #define ADD_BYTE(x)     nga_async_add(sc, &fcs, accm, &alen, (x))
 408
 409         /* Check for bypass mode */
 410         if (!sc->cfg.enabled) {
 411                 NG_FWD_ITEM_HOOK(error, item, sc->async );
 412                 return (error);
 413         }
 414         NGI_GET_M(item, m);
 415
 416         rcvif = m->m_pkthdr.rcvif;
 417
 418         /* Get ACCM; special case LCP frames, which use full ACCM */
 419         accm = sc->cfg.accm;
 420         if (m->m_pkthdr.len >= 4) {
 421                 static const u_char lcphdr[4] = {
 422                     PPP_ALLSTATIONS,
 423                     PPP_UI,
 424                     (u_char)(PPP_LCP >> 8),
 425                     (u_char)(PPP_LCP & 0xff)
 426                 };
 427                 u_char buf[4];
 428
 429                 m_copydata(m, 0, 4, (caddr_t)buf);
 430                 if (bcmp(buf, &lcphdr, 4) == 0)
 431                         accm = ~0;
 432         }
 433
 434         /* Check for overflow */
 435         if (m->m_pkthdr.len > sc->cfg.smru) {
 436                 sc->stats.syncOverflows++;
 437                 NG_FREE_M(m);
 438                 NG_FREE_ITEM(item);
 439                 return (EMSGSIZE);
 440         }
 441
 442         /* Update stats */
 443         sc->stats.syncFrames++;
 444         sc->stats.syncOctets += m->m_pkthdr.len;
 445
 446         /* Initialize async encoded version of input mbuf */
 447         alen = 0;
 448         fcs = PPP_INITFCS;
 449
 450         /* Add beginning sync flag if it's been long enough to need one */
 451         getmicrotime(&time);
 452         if (time.tv_sec >= sc->lasttime + 1) {
 453                 sc->abuf[alen++] = PPP_FLAG;
 454                 sc->lasttime = time.tv_sec;
 455         }
 456
 457         /* Add packet payload */
 458         while (m != NULL) {
 459                 while (m->m_len > 0) {
 460                         ADD_BYTE(*mtod(m, u_char *));
 461                         m->m_data++;
 462                         m->m_len--;
 463                 }
 464                 m = m_free(m);
 465         }
 466
 467         /* Add checksum and final sync flag */
 468         fcs0 = fcs;
 469         ADD_BYTE(~fcs0 & 0xff);
 470         ADD_BYTE(~fcs0 >> 8);
 471         sc->abuf[alen++] = PPP_FLAG;
 472
 473         /* Put frame in an mbuf and ship it off */
 474         if (!(m = m_devget(sc->abuf, alen, 0, rcvif, NULL))) {
 475                 NG_FREE_ITEM(item);
 476                 error = ENOBUFS;
 477         } else {
 478                 NG_FWD_NEW_DATA(error, item, sc->async, m);
 479         }
 480         return (error);
 481 }
 482
 483 /*
 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.
 487  */
 488 static int
 489 nga_rcv_async(const sc_p sc, item_p item)
 490 {
 491         struct ifnet *rcvif;
 492         int error;
 493         struct mbuf *m;
 494
 495         if (!sc->cfg.enabled) {
 496                 NG_FWD_ITEM_HOOK(error, item,  sc->sync);
 497                 return (error);
 498         }
 499         NGI_GET_M(item, m);
 500         rcvif = m->m_pkthdr.rcvif;
 501         while (m) {
 502                 struct mbuf *n;
 503
 504                 for (; m->m_len > 0; m->m_data++, m->m_len--) {
 505                         u_char  ch = *mtod(m, u_char *);
 506
 507                         sc->stats.asyncOctets++;
 508                         if (ch == PPP_FLAG) {   /* Flag overrides everything */
 509                                 int     skip = 0;
 510
 511                                 /* Check for runts */
 512                                 if (sc->slen < 2) {
 513                                         if (sc->slen > 0)
 514                                                 sc->stats.asyncRunts++;
 515                                         goto reset;
 516                                 }
 517
 518                                 /* Verify CRC */
 519                                 if (sc->fcs != PPP_GOODFCS) {
 520                                         sc->stats.asyncBadCheckSums++;
 521                                         goto reset;
 522                                 }
 523                                 sc->slen -= 2;
 524
 525                                 /* Strip address and control fields */
 526                                 if (sc->slen >= 2
 527                                     && sc->sbuf[0] == PPP_ALLSTATIONS
 528                                     && sc->sbuf[1] == PPP_UI)
 529                                         skip = 2;
 530
 531                                 /* Check for frame too big */
 532                                 if (sc->slen - skip > sc->cfg.amru) {
 533                                         sc->stats.asyncOverflows++;
 534                                         goto reset;
 535                                 }
 536
 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,
 542                                                         sc->sync, n);
 543                                         } else {
 544                                                 NG_SEND_DATA_ONLY(error,
 545                                                         sc->sync ,n);
 546                                         }
 547                                 }
 548                                 sc->stats.asyncFrames++;
 549 reset:
 550                                 sc->amode = MODE_NORMAL;
 551                                 sc->fcs = PPP_INITFCS;
 552                                 sc->slen = 0;
 553                                 continue;
 554                         }
 555                         switch (sc->amode) {
 556                         case MODE_NORMAL:
 557                                 if (ch == PPP_ESCAPE) {
 558                                         sc->amode = MODE_ESC;
 559                                         continue;
 560                                 }
 561                                 break;
 562                         case MODE_ESC:
 563                                 ch ^= PPP_TRANS;
 564                                 sc->amode = MODE_NORMAL;
 565                                 break;
 566                         case MODE_HUNT:
 567                         default:
 568                                 continue;
 569                         }
 570
 571                         /* Add byte to frame */
 572                         if (sc->slen >= SYNC_BUF_SIZE(sc->cfg.amru)) {
 573                                 sc->stats.asyncOverflows++;
 574                                 sc->amode = MODE_HUNT;
 575                                 sc->slen = 0;
 576                         } else {
 577                                 sc->sbuf[sc->slen++] = ch;
 578                                 sc->fcs = PPP_FCS(sc->fcs, ch);
 579                         }
 580                 }
 581                 m = m_free(m);
 582         }
 583         if (item)
 584                 NG_FREE_ITEM(item);
 585         return (0);
 586 }
 587
 588 /*
 589  * CRC table
 590  *
 591  * Taken from RFC 1171 Appendix B
 592  */
 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
 626 };