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

Cache object: 049d28ec9f774b959e260390b17f1d2c


[ 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.