sys/netgraph/async/ng_async.c

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