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/11.1/sys/netgraph/ng_frame_relay.c 298813 2016-04-29 21:25:05Z pfg $
   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 #define ERROUT(x)               do { error = (x); goto done; } while (0)
  152 
  153 /*
  154  * Given a DLCI, return the index of the  context table entry for it,
  155  * Allocating a new one if needs be, or -1 if none available.
  156  */
  157 static int
  158 ngfrm_allocate_CTX(sc_p sc, int dlci)
  159 {
  160         u_int   ctxnum = -1;    /* what ctx number we are using */
  161         volatile struct ctxinfo *CTXp = NULL;
  162 
  163         /* Sanity check the dlci value */
  164         if (dlci > 1023)
  165                 return (-1);
  166 
  167         /* Check to see if we already have an entry for this DLCI */
  168         if (sc->ALT[dlci]) {
  169                 if ((ctxnum = sc->ALT[dlci] & CTX_VALUE) < MAX_CT) {
  170                         CTXp = sc->channel + ctxnum;
  171                 } else {
  172                         ctxnum = -1;
  173                         sc->ALT[dlci] = 0;      /* paranoid but... */
  174                 }
  175         }
  176 
  177         /*
  178          * If the index has no valid entry yet, then we need to allocate a
  179          * CTX number to it
  180          */
  181         if (CTXp == NULL) {
  182                 for (ctxnum = 0; ctxnum < MAX_CT; ctxnum++) {
  183                         /*
  184                          * If the VALID flag is empty it is unused
  185                          */
  186                         if ((sc->channel[ctxnum].flags & CHAN_VALID) == 0) {
  187                                 bzero(sc->channel + ctxnum,
  188                                       sizeof(struct ctxinfo));
  189                                 CTXp = sc->channel + ctxnum;
  190                                 sc->ALT[dlci] = ctxnum | CTX_VALID;
  191                                 sc->channel[ctxnum].dlci = dlci;
  192                                 sc->channel[ctxnum].flags = CHAN_VALID;
  193                                 break;
  194                         }
  195                 }
  196         }
  197 
  198         /*
  199          * If we still don't have a CTX pointer, then we never found a free
  200          * spot so give up now..
  201          */
  202         if (!CTXp) {
  203                 log(LOG_ERR, "No CTX available for dlci %d\n", dlci);
  204                 return (-1);
  205         }
  206         return (ctxnum);
  207 }
  208 
  209 /*
  210  * Node constructor
  211  */
  212 static int
  213 ngfrm_constructor(node_p node)
  214 {
  215         sc_p sc;
  216 
  217         sc = malloc(sizeof(*sc), M_NETGRAPH, M_WAITOK | M_ZERO);
  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                 ERROUT(ENETDOWN);
  342 
  343         /* If coming from downstream, decode it to a channel */
  344         dlci = ctxp->dlci;
  345         if (dlci == -1)
  346                 return (ngfrm_decode(NG_HOOK_NODE(hook), item));
  347 
  348         NGI_GET_M(item, m);
  349         /* Derive the softc we will need */
  350         sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  351 
  352         /* If there is no live channel, throw it away */
  353         if ((sc->downstream.hook == NULL)
  354             || ((ctxp->flags & CHAN_ACTIVE) == 0))
  355                 ERROUT(ENETDOWN);
  356 
  357         /* Store the DLCI on the front of the packet */
  358         alen = sc->addrlen;
  359         if (alen == 0)
  360                 alen = 2;       /* default value for transmit */
  361         M_PREPEND(m, alen, M_NOWAIT);
  362         if (m == NULL)
  363                 ERROUT(ENOBUFS);
  364         data = mtod(m, char *);
  365 
  366         /*
  367          * Shift the lowest bits into the address field until we are done.
  368          * First byte is MSBits of addr so work backwards.
  369          */
  370         switch (alen) {
  371         case 2:
  372                 data[0] = data[1] = '\0';
  373                 SHIFTOUT(makeup + 1, data[1], dlci);
  374                 SHIFTOUT(makeup + 0, data[0], dlci);
  375                 data[1] |= BYTEX_EA;
  376                 break;
  377         case 3:
  378                 data[0] = data[1] = data[2] = '\0';
  379                 SHIFTOUT(makeup + 3, data[2], dlci);    /* 3 and 2 is correct */
  380                 SHIFTOUT(makeup + 1, data[1], dlci);
  381                 SHIFTOUT(makeup + 0, data[0], dlci);
  382                 data[2] |= BYTEX_EA;
  383                 break;
  384         case 4:
  385                 data[0] = data[1] = data[2] = data[3] = '\0';
  386                 SHIFTOUT(makeup + 3, data[3], dlci);
  387                 SHIFTOUT(makeup + 2, data[2], dlci);
  388                 SHIFTOUT(makeup + 1, data[1], dlci);
  389                 SHIFTOUT(makeup + 0, data[0], dlci);
  390                 data[3] |= BYTEX_EA;
  391                 break;
  392         default:
  393                 panic("%s", __func__);
  394         }
  395 
  396         /* Send it */
  397         NG_FWD_NEW_DATA(error, item, sc->downstream.hook, m);
  398         return (error);
  399 
  400 done:
  401         NG_FREE_ITEM(item);
  402         NG_FREE_M(m);
  403         return (error);
  404 }
  405 
  406 /*
  407  * Decode an incoming frame coming from the switch
  408  */
  409 static int
  410 ngfrm_decode(node_p node, item_p item)
  411 {
  412         const sc_p  sc = NG_NODE_PRIVATE(node);
  413         char       *data;
  414         int         alen;
  415         u_int       dlci = 0;
  416         int         error = 0;
  417         int         ctxnum;
  418         struct mbuf *m;
  419 
  420         NGI_GET_M(item, m);
  421         if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL)
  422                 ERROUT(ENOBUFS);
  423         data = mtod(m, char *);
  424         if ((alen = sc->addrlen) == 0) {
  425                 sc->addrlen = alen = ngfrm_addrlen(data);
  426         }
  427         switch (alen) {
  428         case 2:
  429                 SHIFTIN(makeup + 0, data[0], dlci);
  430                 SHIFTIN(makeup + 1, data[1], dlci);
  431                 break;
  432         case 3:
  433                 SHIFTIN(makeup + 0, data[0], dlci);
  434                 SHIFTIN(makeup + 1, data[1], dlci);
  435                 SHIFTIN(makeup + 3, data[2], dlci);     /* 3 and 2 is correct */
  436                 break;
  437         case 4:
  438                 SHIFTIN(makeup + 0, data[0], dlci);
  439                 SHIFTIN(makeup + 1, data[1], dlci);
  440                 SHIFTIN(makeup + 2, data[2], dlci);
  441                 SHIFTIN(makeup + 3, data[3], dlci);
  442                 break;
  443         default:
  444                 ERROUT(EINVAL);
  445         }
  446 
  447         if (dlci > 1023)
  448                 ERROUT(EINVAL);
  449         ctxnum = sc->ALT[dlci];
  450         if ((ctxnum & CTX_VALID) && sc->channel[ctxnum &= CTX_VALUE].hook) {
  451                 /* Send it */
  452                 m_adj(m, alen);
  453                 NG_FWD_NEW_DATA(error, item, sc->channel[ctxnum].hook, m);
  454                 return (error);
  455         } else {
  456                 error = ENETDOWN;
  457         }
  458 done:
  459         NG_FREE_ITEM(item);
  460         NG_FREE_M(m);
  461         return (error);
  462 }
  463 
  464 /*
  465  * Shutdown node
  466  */
  467 static int
  468 ngfrm_shutdown(node_p node)
  469 {
  470         const sc_p sc = NG_NODE_PRIVATE(node);
  471 
  472         NG_NODE_SET_PRIVATE(node, NULL);
  473         free(sc, M_NETGRAPH);
  474         NG_NODE_UNREF(node);
  475         return (0);
  476 }
  477 
  478 /*
  479  * Hook disconnection
  480  *
  481  * Invalidate the private data associated with this dlci.
  482  * For this type, removal of the last link resets tries to destroy the node.
  483  */
  484 static int
  485 ngfrm_disconnect(hook_p hook)
  486 {
  487         const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
  488         struct ctxinfo *const cp = NG_HOOK_PRIVATE(hook);
  489         int dlci;
  490 
  491         /* If it's a regular dlci hook, then free resources etc.. */
  492         if (cp != NULL) {
  493                 cp->hook = NULL;
  494                 dlci = cp->dlci;
  495                 if (dlci != -1)
  496                         sc->ALT[dlci] = 0;
  497                 cp->flags = 0;
  498                 sc->datahooks--;
  499         }
  500         if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
  501         && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook))))
  502                 ng_rmnode_self(NG_HOOK_NODE(hook));
  503         return (0);
  504 }

Cache object: 708677d31838f564000dd386125aa02b


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