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_frame_relay.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  * ng_frame_relay.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: Julian Elischer <julian@freebsd.org>
   39  *
   40  * $FreeBSD: releng/8.1/sys/netgraph/ng_frame_relay.c 199583 2009-11-20 15:27:52Z jhb $
   41  * $Whistle: ng_frame_relay.c,v 1.20 1999/11/01 09:24:51 julian Exp $
   42  */
   43 
   44 /*
   45  * This node implements the frame relay protocol, not including
   46  * the LMI line management. This means basically keeping track
   47  * of which DLCI's are active, doing frame (de)multiplexing, etc.
   48  *
   49  * It has a 'downstream' hook that goes to the line, and a
   50  * hook for each DLCI (eg, 'dlci16').
   51  */
   52 
   53 #include <sys/param.h>
   54 #include <sys/systm.h>
   55 #include <sys/kernel.h>
   56 #include <sys/errno.h>
   57 #include <sys/malloc.h>
   58 #include <sys/mbuf.h>
   59 #include <sys/syslog.h>
   60 #include <sys/ctype.h>
   61 
   62 #include <netgraph/ng_message.h>
   63 #include <netgraph/netgraph.h>
   64 #include <netgraph/ng_frame_relay.h>
   65 
   66 /*
   67  * Line info, and status per channel.
   68  */
   69 struct ctxinfo {                /* one per active hook */
   70         u_int   flags;
   71 #define CHAN_VALID      0x01    /* assigned to a channel */
   72 #define CHAN_ACTIVE     0x02    /* bottom level active */
   73         int     dlci;           /* the dlci assigned to this context */
   74         hook_p  hook;           /* if there's a hook assigned.. */
   75 };
   76 
   77 #define MAX_CT 16               /* # of dlci's active at a time (POWER OF 2!) */
   78 struct frmrel_softc {
   79         int     unit;           /* which card are we? */
   80         int     datahooks;      /* number of data hooks attached */
   81         node_p  node;           /* netgraph node */
   82         int     addrlen;        /* address header length */
   83         int     flags;          /* state */
   84         int     mtu;            /* guess */
   85         u_char  remote_seq;     /* sequence number the remote sent */
   86         u_char  local_seq;      /* sequence number the remote rcvd */
   87         u_short ALT[1024];      /* map DLCIs to CTX */
   88 #define CTX_VALID       0x8000          /* this bit means it's a valid CTX */
   89 #define CTX_VALUE       (MAX_CT - 1)    /* mask for context part */
   90         struct  ctxinfo channel[MAX_CT];
   91         struct  ctxinfo downstream;
   92 };
   93 typedef struct frmrel_softc *sc_p;
   94 
   95 #define BYTEX_EA        0x01    /* End Address. Always 0 on byte1 */
   96 #define BYTE1_C_R       0x02
   97 #define BYTE2_FECN      0x08    /* forwards congestion notification */
   98 #define BYTE2_BECN      0x04    /* Backward congestion notification */
   99 #define BYTE2_DE        0x02    /* Discard elligability */
  100 #define LASTBYTE_D_C    0x02    /* last byte is dl_core or dlci info */
  101 
  102 /* Used to do headers */
  103 const static struct segment {
  104         u_char  mask;
  105         u_char  shift;
  106         u_char  width;
  107 } makeup[] = {
  108         { 0xfc, 2, 6 },
  109         { 0xf0, 4, 4 },
  110         { 0xfe, 1, 7 },
  111         { 0xfc, 2, 6 }
  112 };
  113 
  114 #define SHIFTIN(segment, byte, dlci)                                         \
  115         {                                                                    \
  116                 (dlci) <<= (segment)->width;                                 \
  117                 (dlci) |=                                                    \
  118                         (((byte) & (segment)->mask) >> (segment)->shift);    \
  119         }
  120 
  121 #define SHIFTOUT(segment, byte, dlci)                                        \
  122         {                                                                    \
  123                 (byte) |= (((dlci) << (segment)->shift) & (segment)->mask);  \
  124                 (dlci) >>= (segment)->width;                                 \
  125         }
  126 
  127 /* Netgraph methods */
  128 static ng_constructor_t ngfrm_constructor;
  129 static ng_shutdown_t    ngfrm_shutdown;
  130 static ng_newhook_t     ngfrm_newhook;
  131 static ng_rcvdata_t     ngfrm_rcvdata;
  132 static ng_disconnect_t  ngfrm_disconnect;
  133 
  134 /* Other internal functions */
  135 static int ngfrm_decode(node_p node, item_p item);
  136 static int ngfrm_addrlen(char *hdr);
  137 static int ngfrm_allocate_CTX(sc_p sc, int dlci);
  138 
  139 /* Netgraph type */
  140 static struct ng_type typestruct = {
  141         .version =      NG_ABI_VERSION,
  142         .name =         NG_FRAMERELAY_NODE_TYPE,
  143         .constructor =  ngfrm_constructor,
  144         .shutdown =     ngfrm_shutdown,
  145         .newhook =      ngfrm_newhook,
  146         .rcvdata =      ngfrm_rcvdata,
  147         .disconnect =   ngfrm_disconnect,
  148 };
  149 NETGRAPH_INIT(framerelay, &typestruct);
  150 
  151 /*
  152  * Given a DLCI, return the index of the  context table entry for it,
  153  * Allocating a new one if needs be, or -1 if none available.
  154  */
  155 static int
  156 ngfrm_allocate_CTX(sc_p sc, int dlci)
  157 {
  158         u_int   ctxnum = -1;    /* what ctx number we are using */
  159         volatile struct ctxinfo *CTXp = NULL;
  160 
  161         /* Sanity check the dlci value */
  162         if (dlci > 1023)
  163                 return (-1);
  164 
  165         /* Check to see if we already have an entry for this DLCI */
  166         if (sc->ALT[dlci]) {
  167                 if ((ctxnum = sc->ALT[dlci] & CTX_VALUE) < MAX_CT) {
  168                         CTXp = sc->channel + ctxnum;
  169                 } else {
  170                         ctxnum = -1;
  171                         sc->ALT[dlci] = 0;      /* paranoid but... */
  172                 }
  173         }
  174 
  175         /*
  176          * If the index has no valid entry yet, then we need to allocate a
  177          * CTX number to it
  178          */
  179         if (CTXp == NULL) {
  180                 for (ctxnum = 0; ctxnum < MAX_CT; ctxnum++) {
  181                         /*
  182                          * If the VALID flag is empty it is unused
  183                          */
  184                         if ((sc->channel[ctxnum].flags & CHAN_VALID) == 0) {
  185                                 bzero(sc->channel + ctxnum,
  186                                       sizeof(struct ctxinfo));
  187                                 CTXp = sc->channel + ctxnum;
  188                                 sc->ALT[dlci] = ctxnum | CTX_VALID;
  189                                 sc->channel[ctxnum].dlci = dlci;
  190                                 sc->channel[ctxnum].flags = CHAN_VALID;
  191                                 break;
  192                         }
  193                 }
  194         }
  195 
  196         /*
  197          * If we still don't have a CTX pointer, then we never found a free
  198          * spot so give up now..
  199          */
  200         if (!CTXp) {
  201                 log(LOG_ERR, "No CTX available for dlci %d\n", dlci);
  202                 return (-1);
  203         }
  204         return (ctxnum);
  205 }
  206 
  207 /*
  208  * Node constructor
  209  */
  210 static int
  211 ngfrm_constructor(node_p node)
  212 {
  213         sc_p sc;
  214 
  215         sc = malloc(sizeof(*sc), M_NETGRAPH, M_NOWAIT | M_ZERO);
  216         if (!sc)
  217                 return (ENOMEM);
  218         sc->addrlen = 2;        /* default */
  219 
  220         /* Link the node and our private info */
  221         NG_NODE_SET_PRIVATE(node, sc);
  222         sc->node = node;
  223         return (0);
  224 }
  225 
  226 /*
  227  * Add a new hook
  228  *
  229  * We allow hooks called "debug", "downstream" and dlci[0-1023]
  230  * The hook's private info points to our stash of info about that
  231  * channel. A NULL pointer is debug and a DLCI of -1 means downstream.
  232  */
  233 static int
  234 ngfrm_newhook(node_p node, hook_p hook, const char *name)
  235 {
  236         const sc_p sc = NG_NODE_PRIVATE(node);
  237         const char *cp;
  238         char *eptr;
  239         int dlci = 0;
  240         int ctxnum;
  241 
  242         /* Check if it's our friend the control hook */
  243         if (strcmp(name, NG_FRAMERELAY_HOOK_DEBUG) == 0) {
  244                 NG_HOOK_SET_PRIVATE(hook, NULL);        /* paranoid */
  245                 return (0);
  246         }
  247 
  248         /*
  249          * All other hooks either start with 'dlci' and have a decimal
  250          * trailing channel number up to 4 digits, or are the downstream
  251          * hook.
  252          */
  253         if (strncmp(name, NG_FRAMERELAY_HOOK_DLCI,
  254             strlen(NG_FRAMERELAY_HOOK_DLCI)) != 0) {
  255 
  256                 /* It must be the downstream connection */
  257                 if (strcmp(name, NG_FRAMERELAY_HOOK_DOWNSTREAM) != 0)
  258                         return EINVAL;
  259 
  260                 /* Make sure we haven't already got one (paranoid) */
  261                 if (sc->downstream.hook)
  262                         return (EADDRINUSE);
  263 
  264                 /* OK add it */
  265                 NG_HOOK_SET_PRIVATE(hook, &sc->downstream);
  266                 sc->downstream.hook = hook;
  267                 sc->downstream.dlci = -1;
  268                 sc->downstream.flags |= CHAN_ACTIVE;
  269                 sc->datahooks++;
  270                 return (0);
  271         }
  272 
  273         /* Must be a dlci hook at this point */
  274         cp = name + strlen(NG_FRAMERELAY_HOOK_DLCI);
  275         if (!isdigit(*cp) || (cp[0] == '' && cp[1] != '\0'))
  276                 return (EINVAL);
  277         dlci = (int)strtoul(cp, &eptr, 10);
  278         if (*eptr != '\0' || dlci < 0 || dlci > 1023)
  279                 return (EINVAL);
  280 
  281         /*
  282          * We have a dlci, now either find it, or allocate it. It's possible
  283          * that we might have seen packets for it already and made an entry
  284          * for it.
  285          */
  286         ctxnum = ngfrm_allocate_CTX(sc, dlci);
  287         if (ctxnum == -1)
  288                 return (ENOBUFS);
  289 
  290         /*
  291          * Be paranoid: if it's got a hook already, that dlci is in use .
  292          * Generic code can not catch all the synonyms (e.g. dlci016 vs
  293          * dlci16)
  294          */
  295         if (sc->channel[ctxnum].hook != NULL)
  296                 return (EADDRINUSE);
  297 
  298         /*
  299          * Put our hooks into it (pun not intended)
  300          */
  301         sc->channel[ctxnum].flags |= CHAN_ACTIVE;
  302         NG_HOOK_SET_PRIVATE(hook, sc->channel + ctxnum);
  303         sc->channel[ctxnum].hook = hook;
  304         sc->datahooks++;
  305         return (0);
  306 }
  307 
  308 /*
  309  * Count up the size of the address header if we don't already know
  310  */
  311 int
  312 ngfrm_addrlen(char *hdr)
  313 {
  314         if (hdr[0] & BYTEX_EA)
  315                 return 0;
  316         if (hdr[1] & BYTEX_EA)
  317                 return 2;
  318         if (hdr[2] & BYTEX_EA)
  319                 return 3;
  320         if (hdr[3] & BYTEX_EA)
  321                 return 4;
  322         return 0;
  323 }
  324 
  325 /*
  326  * Receive data packet
  327  */
  328 static int
  329 ngfrm_rcvdata(hook_p hook, item_p item)
  330 {
  331         struct  ctxinfo *const ctxp = NG_HOOK_PRIVATE(hook);
  332         struct  mbuf *m = NULL;
  333         int     error = 0;
  334         int     dlci;
  335         sc_p    sc;
  336         int     alen;
  337         char   *data;
  338 
  339         /* Data doesn't come in from just anywhere (e.g debug hook) */
  340         if (ctxp == NULL) {
  341                 error = ENETDOWN;
  342                 goto bad;
  343         }
  344 
  345         /* If coming from downstream, decode it to a channel */
  346         dlci = ctxp->dlci;
  347         if (dlci == -1)
  348                 return (ngfrm_decode(NG_HOOK_NODE(hook), item));
  349 
  350         NGI_GET_M(item, m);
  351         /* Derive the softc we will need */
  352         sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  353 
  354         /* If there is no live channel, throw it away */
  355         if ((sc->downstream.hook == NULL)
  356             || ((ctxp->flags & CHAN_ACTIVE) == 0)) {
  357                 error = ENETDOWN;
  358                 goto bad;
  359         }
  360 
  361         /* Store the DLCI on the front of the packet */
  362         alen = sc->addrlen;
  363         if (alen == 0)
  364                 alen = 2;       /* default value for transmit */
  365         M_PREPEND(m, alen, M_DONTWAIT);
  366         if (m == NULL) {
  367                 error = ENOBUFS;
  368                 goto bad;
  369         }
  370         data = mtod(m, char *);
  371 
  372         /*
  373          * Shift the lowest bits into the address field untill we are done.
  374          * First byte is MSBits of addr so work backwards.
  375          */
  376         switch (alen) {
  377         case 2:
  378                 data[0] = data[1] = '\0';
  379                 SHIFTOUT(makeup + 1, data[1], dlci);
  380                 SHIFTOUT(makeup + 0, data[0], dlci);
  381                 data[1] |= BYTEX_EA;
  382                 break;
  383         case 3:
  384                 data[0] = data[1] = data[2] = '\0';
  385                 SHIFTOUT(makeup + 3, data[2], dlci);    /* 3 and 2 is correct */
  386                 SHIFTOUT(makeup + 1, data[1], dlci);
  387                 SHIFTOUT(makeup + 0, data[0], dlci);
  388                 data[2] |= BYTEX_EA;
  389                 break;
  390         case 4:
  391                 data[0] = data[1] = data[2] = data[3] = '\0';
  392                 SHIFTOUT(makeup + 3, data[3], dlci);
  393                 SHIFTOUT(makeup + 2, data[2], dlci);
  394                 SHIFTOUT(makeup + 1, data[1], dlci);
  395                 SHIFTOUT(makeup + 0, data[0], dlci);
  396                 data[3] |= BYTEX_EA;
  397                 break;
  398         default:
  399                 panic(__func__);
  400         }
  401 
  402         /* Send it */
  403         NG_FWD_NEW_DATA(error, item, sc->downstream.hook, m);
  404         return (error);
  405 
  406 bad:
  407         NG_FREE_ITEM(item);
  408         NG_FREE_M(m);
  409         return (error);
  410 }
  411 
  412 /*
  413  * Decode an incoming frame coming from the switch
  414  */
  415 static int
  416 ngfrm_decode(node_p node, item_p item)
  417 {
  418         const sc_p  sc = NG_NODE_PRIVATE(node);
  419         char       *data;
  420         int         alen;
  421         u_int       dlci = 0;
  422         int         error = 0;
  423         int         ctxnum;
  424         struct mbuf *m;
  425 
  426         NGI_GET_M(item, m);
  427         if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL) {
  428                 error = ENOBUFS;
  429                 goto out;
  430         }
  431         data = mtod(m, char *);
  432         if ((alen = sc->addrlen) == 0) {
  433                 sc->addrlen = alen = ngfrm_addrlen(data);
  434         }
  435         switch (alen) {
  436         case 2:
  437                 SHIFTIN(makeup + 0, data[0], dlci);
  438                 SHIFTIN(makeup + 1, data[1], dlci);
  439                 break;
  440         case 3:
  441                 SHIFTIN(makeup + 0, data[0], dlci);
  442                 SHIFTIN(makeup + 1, data[1], dlci);
  443                 SHIFTIN(makeup + 3, data[2], dlci);     /* 3 and 2 is correct */
  444                 break;
  445         case 4:
  446                 SHIFTIN(makeup + 0, data[0], dlci);
  447                 SHIFTIN(makeup + 1, data[1], dlci);
  448                 SHIFTIN(makeup + 2, data[2], dlci);
  449                 SHIFTIN(makeup + 3, data[3], dlci);
  450                 break;
  451         default:
  452                 error = EINVAL;
  453                 goto out;
  454         }
  455 
  456         if (dlci > 1023) {
  457                 error = EINVAL;
  458                 goto out;
  459         }
  460         ctxnum = sc->ALT[dlci];
  461         if ((ctxnum & CTX_VALID) && sc->channel[ctxnum &= CTX_VALUE].hook) {
  462                 /* Send it */
  463                 m_adj(m, alen);
  464                 NG_FWD_NEW_DATA(error, item, sc->channel[ctxnum].hook, m);
  465                 return (error);
  466         } else {
  467                 error = ENETDOWN;
  468         }
  469 out:
  470         NG_FREE_ITEM(item);
  471         NG_FREE_M(m);
  472         return (error);
  473 }
  474 
  475 /*
  476  * Shutdown node
  477  */
  478 static int
  479 ngfrm_shutdown(node_p node)
  480 {
  481         const sc_p sc = NG_NODE_PRIVATE(node);
  482 
  483         NG_NODE_SET_PRIVATE(node, NULL);
  484         free(sc, M_NETGRAPH);
  485         NG_NODE_UNREF(node);
  486         return (0);
  487 }
  488 
  489 /*
  490  * Hook disconnection
  491  *
  492  * Invalidate the private data associated with this dlci.
  493  * For this type, removal of the last link resets tries to destroy the node.
  494  */
  495 static int
  496 ngfrm_disconnect(hook_p hook)
  497 {
  498         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  499         struct ctxinfo *const cp = NG_HOOK_PRIVATE(hook);
  500         int dlci;
  501 
  502         /* If it's a regular dlci hook, then free resources etc.. */
  503         if (cp != NULL) {
  504                 cp->hook = NULL;
  505                 dlci = cp->dlci;
  506                 if (dlci != -1)
  507                         sc->ALT[dlci] = 0;
  508                 cp->flags = 0;
  509                 sc->datahooks--;
  510         }
  511         if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
  512         && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
  513                 ng_rmnode_self(NG_HOOK_NODE(hook));
  514         return (0);
  515 }

Cache object: 167dc7b51e6db953d3f4cd48f96f9975


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