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