The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netgraph/ng_async.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: 076479fe8d992140842974bba49ee555


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.