sys/netgraph/ng_sppp.c

   1 /*
   2  * ng_sppp.c Netgraph to Sppp module.
   3  */
   4
   5 /*-
   6  * Copyright (C) 2002-2004 Cronyx Engineering.
   7  * Copyright (C) 2002-2004 Roman Kurakin <rik@cronyx.ru>
   8  *
   9  * This software is distributed with NO WARRANTIES, not even the implied
  10  * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Authors grant any other persons or organisations a permission to use,
  13  * modify and redistribute this software in source and binary forms,
  14  * as long as this message is kept with the software, all derivative
  15  * works or modified versions.
  16  *
  17  * Cronyx Id: ng_sppp.c,v 1.1.2.10 2004/03/01 15:17:21 rik Exp $
  18  */
  19 #include <sys/cdefs.h>
  20 __FBSDID("$FreeBSD$");
  21
  22 #include <sys/param.h>
  23 #include <sys/systm.h>
  24 #include <sys/errno.h>
  25 #include <sys/kernel.h>
  26 #include <sys/malloc.h>
  27 #include <sys/mbuf.h>
  28 #include <sys/errno.h>
  29 #include <sys/sockio.h>
  30 #include <sys/socket.h>
  31 #include <sys/syslog.h>
  32 #include <sys/libkern.h>
  33
  34 #include <net/if.h>
  35 #include <net/if_types.h>
  36 #include <net/bpf.h>
  37 #include <net/if_sppp.h>
  38
  39 #include <netinet/in.h>
  40
  41 #include <netgraph/ng_message.h>
  42 #include <netgraph/netgraph.h>
  43 #include <netgraph/ng_parse.h>
  44 #include <netgraph/ng_sppp.h>
  45
  46 #ifdef NG_SEPARATE_MALLOC
  47 MALLOC_DEFINE(M_NETGRAPH_SPPP, "netgraph_sppp", "netgraph sppp node ");
  48 #else
  49 #define M_NETGRAPH_SPPP M_NETGRAPH
  50 #endif
  51
  52 /* Node private data */
  53 struct ng_sppp_private {
  54         struct  ifnet *ifp;             /* Our interface */
  55         int     unit;                   /* Interface unit number */
  56         node_p  node;                   /* Our netgraph node */
  57         hook_p  hook;                   /* Hook */
  58 };
  59 typedef struct ng_sppp_private *priv_p;
  60
  61 /* Interface methods */
  62 static void     ng_sppp_start (struct ifnet *ifp);
  63 static int      ng_sppp_ioctl (struct ifnet *ifp, u_long cmd, caddr_t data);
  64
  65 /* Netgraph methods */
  66 static ng_constructor_t ng_sppp_constructor;
  67 static ng_rcvmsg_t      ng_sppp_rcvmsg;
  68 static ng_shutdown_t    ng_sppp_shutdown;
  69 static ng_newhook_t     ng_sppp_newhook;
  70 static ng_rcvdata_t     ng_sppp_rcvdata;
  71 static ng_disconnect_t  ng_sppp_disconnect;
  72
  73 /* List of commands and how to convert arguments to/from ASCII */
  74 static const struct ng_cmdlist ng_sppp_cmds[] = {
  75         {
  76           NGM_SPPP_COOKIE,
  77           NGM_SPPP_GET_IFNAME,
  78           "getifname",
  79           NULL,
  80           &ng_parse_string_type
  81         },
  82         { 0 }
  83 };
  84
  85 /* Node type descriptor */
  86 static struct ng_type typestruct = {
  87         .version =      NG_ABI_VERSION,
  88         .name =         NG_SPPP_NODE_TYPE,
  89         .constructor =  ng_sppp_constructor,
  90         .rcvmsg =       ng_sppp_rcvmsg,
  91         .shutdown =     ng_sppp_shutdown,
  92         .newhook =      ng_sppp_newhook,
  93         .rcvdata =      ng_sppp_rcvdata,
  94         .disconnect =   ng_sppp_disconnect,
  95         .cmdlist =      ng_sppp_cmds,
  96 };
  97 NETGRAPH_INIT(sppp, &typestruct);
  98
  99 MODULE_DEPEND (ng_sppp, sppp, 1, 1, 1);
 100
 101 /* We keep a bitmap indicating which unit numbers are free.
 102    Zero means the unit number is free, one means it's taken. */
 103 static unsigned char    *ng_sppp_units = NULL;
 104 static unsigned char    ng_sppp_units_len = 0;
 105 static unsigned char    ng_units_in_use = 0;
 106
 107 /*
 108  * Find the first free unit number for a new interface.
 109  * Increase the size of the unit bitmap as necessary.
 110  */
 111 static __inline int
 112 ng_sppp_get_unit (int *unit)
 113 {
 114         int index, bit;
 115         unsigned char mask;
 116
 117         for (index = 0; index < ng_sppp_units_len
 118             && ng_sppp_units[index] == 0xFF; index++);
 119         if (index == ng_sppp_units_len) {               /* extend array */
 120                 unsigned char *newarray;
 121                 int newlen;
 122
 123                 newlen = (2 * ng_sppp_units_len) + sizeof (*ng_sppp_units);
 124                 newarray = malloc (newlen * sizeof (*ng_sppp_units),
 125                     M_NETGRAPH_SPPP, M_NOWAIT);
 126                 if (newarray == NULL)
 127                         return (ENOMEM);
 128                 bcopy (ng_sppp_units, newarray,
 129                     ng_sppp_units_len * sizeof (*ng_sppp_units));
 130                 bzero (newarray + ng_sppp_units_len,
 131                     newlen - ng_sppp_units_len);
 132                 if (ng_sppp_units != NULL)
 133                         free (ng_sppp_units, M_NETGRAPH_SPPP);
 134                 ng_sppp_units = newarray;
 135                 ng_sppp_units_len = newlen;
 136         }
 137         mask = ng_sppp_units[index];
 138         for (bit = 0; (mask & 1) != 0; bit++)
 139                 mask >>= 1;
 140         KASSERT ((bit >= 0 && bit < NBBY),
 141             ("%s: word=%d bit=%d", __func__, ng_sppp_units[index], bit));
 142         ng_sppp_units[index] |= (1 << bit);
 143         *unit = (index * NBBY) + bit;
 144         ng_units_in_use++;
 145         return (0);
 146 }
 147
 148 /*
 149  * Free a no longer needed unit number.
 150  */
 151 static __inline void
 152 ng_sppp_free_unit (int unit)
 153 {
 154         int index, bit;
 155
 156         index = unit / NBBY;
 157         bit = unit % NBBY;
 158         KASSERT (index < ng_sppp_units_len,
 159             ("%s: unit=%d len=%d", __func__, unit, ng_sppp_units_len));
 160         KASSERT ((ng_sppp_units[index] & (1 << bit)) != 0,
 161             ("%s: unit=%d is free", __func__, unit));
 162         ng_sppp_units[index] &= ~(1 << bit);
 163
 164         ng_units_in_use--;
 165         if (ng_units_in_use == 0) {
 166                 free (ng_sppp_units, M_NETGRAPH_SPPP);
 167                 ng_sppp_units_len = 0;
 168                 ng_sppp_units = NULL;
 169         }
 170 }
 171
 172 /************************************************************************
 173                         INTERFACE STUFF
 174  ************************************************************************/
 175
 176 /*
 177  * Process an ioctl for the interface
 178  */
 179 static int
 180 ng_sppp_ioctl (struct ifnet *ifp, u_long command, caddr_t data)
 181 {
 182         int error = 0;
 183
 184         error = sppp_ioctl (ifp, command, data);
 185         if (error)
 186                 return error;
 187
 188         return error;
 189 }
 190
 191 /*
 192  * This routine should never be called
 193  */
 194
 195 static void
 196 ng_sppp_start (struct ifnet *ifp)
 197 {
 198         struct mbuf *m;
 199         int len, error = 0;
 200         priv_p priv = ifp->if_softc;
 201
 202         /* Check interface flags */
 203         /*
 204          * This has side effects. It is not good idea to stop sending if we
 205          * are not UP. If we are not running we still want to send LCP term
 206          * packets.
 207          */
 208 /*      if (!((ifp->if_flags & IFF_UP) && */
 209 /*          (ifp->if_drv_flags & IFF_DRV_RUNNING))) { */
 210 /*              return;*/
 211 /*      }*/
 212
 213         if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
 214                 return;
 215
 216         if (!priv->hook)
 217                 return;
 218
 219         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 220
 221         while ((m = sppp_dequeue (ifp)) != NULL) {
 222                 BPF_MTAP (ifp, m);
 223                 len = m->m_pkthdr.len;
 224
 225                 NG_SEND_DATA_ONLY (error, priv->hook, m);
 226
 227                 if (error) {
 228                         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 229                         return;
 230                 }
 231         }
 232         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 233 }
 234
 235 /************************************************************************
 236                         NETGRAPH NODE STUFF
 237  ************************************************************************/
 238
 239 /*
 240  * Constructor for a node
 241  */
 242 static int
 243 ng_sppp_constructor (node_p node)
 244 {
 245         struct sppp *pp;
 246         struct ifnet *ifp;
 247         priv_p priv;
 248         int error = 0;
 249
 250         /* Allocate node and interface private structures */
 251         priv = malloc (sizeof(*priv), M_NETGRAPH_SPPP, M_NOWAIT|M_ZERO);
 252         if (priv == NULL)
 253                 return (ENOMEM);
 254
 255         ifp = if_alloc(IFT_PPP);
 256         if (ifp == NULL) {
 257                 free (priv, M_NETGRAPH_SPPP);
 258                 return (ENOSPC);
 259         }
 260         pp = IFP2SP(ifp);
 261
 262         /* Link them together */
 263         ifp->if_softc = priv;
 264         priv->ifp = ifp;
 265
 266         /* Get an interface unit number */
 267         if ((error = ng_sppp_get_unit(&priv->unit)) != 0) {
 268                 free (pp, M_NETGRAPH_SPPP);
 269                 free (priv, M_NETGRAPH_SPPP);
 270                 return (error);
 271         }
 272
 273
 274         /* Link together node and private info */
 275         NG_NODE_SET_PRIVATE (node, priv);
 276         priv->node = node;
 277
 278         /* Initialize interface structure */
 279         if_initname (SP2IFP(pp), NG_SPPP_IFACE_NAME, priv->unit);
 280         ifp->if_start = ng_sppp_start;
 281         ifp->if_ioctl = ng_sppp_ioctl;
 282         ifp->if_watchdog = NULL;
 283         ifp->if_flags = (IFF_POINTOPOINT|IFF_MULTICAST);
 284
 285         /* Give this node the same name as the interface (if possible) */
 286         if (ng_name_node(node, SP2IFP(pp)->if_xname) != 0)
 287                 log (LOG_WARNING, "%s: can't acquire netgraph name\n",
 288                     SP2IFP(pp)->if_xname);
 289
 290         /* Attach the interface */
 291         sppp_attach (ifp);
 292         if_attach (ifp);
 293         bpfattach (ifp, DLT_NULL, sizeof(u_int32_t));
 294
 295         /* Done */
 296         return (0);
 297 }
 298
 299 /*
 300  * Give our ok for a hook to be added
 301  */
 302 static int
 303 ng_sppp_newhook (node_p node, hook_p hook, const char *name)
 304 {
 305         priv_p priv = NG_NODE_PRIVATE (node);
 306
 307         if (strcmp (name, NG_SPPP_HOOK_DOWNSTREAM) != 0)
 308                 return (EINVAL);
 309
 310         if (priv->hook)
 311                 return (EISCONN);
 312
 313         priv->hook = hook;
 314         NG_HOOK_SET_PRIVATE (hook, priv);
 315
 316         return (0);
 317 }
 318
 319 /*
 320  * Receive a control message
 321  */
 322 static int
 323 ng_sppp_rcvmsg (node_p node, item_p item, hook_p lasthook)
 324 {
 325         const priv_p priv = NG_NODE_PRIVATE (node);
 326         struct ng_mesg *msg = NULL;
 327         struct ng_mesg *resp = NULL;
 328         struct sppp *const pp = IFP2SP(priv->ifp);
 329         int error = 0;
 330
 331         NGI_GET_MSG (item, msg);
 332         switch (msg->header.typecookie) {
 333         case NGM_SPPP_COOKIE:
 334                 switch (msg->header.cmd) {
 335                 case NGM_SPPP_GET_IFNAME:
 336                         NG_MKRESPONSE (resp, msg, IFNAMSIZ, M_NOWAIT);
 337                         if (!resp) {
 338                                 error = ENOMEM;
 339                                 break;
 340                         }
 341                         strlcpy(resp->data, SP2IFP(pp)->if_xname, IFNAMSIZ);
 342                         break;
 343
 344                 default:
 345                         error = EINVAL;
 346                         break;
 347                 }
 348                 break;
 349         default:
 350                 error = EINVAL;
 351                 break;
 352         }
 353         NG_RESPOND_MSG (error, node, item, resp);
 354         NG_FREE_MSG (msg);
 355         return (error);
 356 }
 357
 358 /*
 359  * Recive data from a hook. Pass the packet to the correct input routine.
 360  */
 361 static int
 362 ng_sppp_rcvdata (hook_p hook, item_p item)
 363 {
 364         struct mbuf *m;
 365         const priv_p priv = NG_NODE_PRIVATE (NG_HOOK_NODE (hook));
 366         struct sppp *const pp = IFP2SP(priv->ifp);
 367
 368         NGI_GET_M (item, m);
 369         NG_FREE_ITEM (item);
 370         /* Sanity checks */
 371         KASSERT (m->m_flags & M_PKTHDR, ("%s: not pkthdr", __func__));
 372         if ((SP2IFP(pp)->if_flags & IFF_UP) == 0) {
 373                 NG_FREE_M (m);
 374                 return (ENETDOWN);
 375         }
 376
 377         /* Update interface stats */
 378         SP2IFP(pp)->if_ipackets++;
 379
 380         /* Note receiving interface */
 381         m->m_pkthdr.rcvif = SP2IFP(pp);
 382
 383         /* Berkeley packet filter */
 384         BPF_MTAP (SP2IFP(pp), m);
 385
 386         /* Send packet */
 387         sppp_input (SP2IFP(pp), m);
 388         return 0;
 389 }
 390
 391 /*
 392  * Shutdown and remove the node and its associated interface.
 393  */
 394 static int
 395 ng_sppp_shutdown (node_p node)
 396 {
 397         const priv_p priv = NG_NODE_PRIVATE(node);
 398         /* Detach from the packet filter list of interfaces. */
 399         bpfdetach (priv->ifp);
 400         sppp_detach (priv->ifp);
 401         if_detach (priv->ifp);
 402         if_free(priv->ifp);
 403         ng_sppp_free_unit (priv->unit);
 404         free (priv, M_NETGRAPH_SPPP);
 405         NG_NODE_SET_PRIVATE (node, NULL);
 406         NG_NODE_UNREF (node);
 407         return (0);
 408 }
 409
 410 /*
 411  * Hook disconnection.
 412  */
 413 static int
 414 ng_sppp_disconnect (hook_p hook)
 415 {
 416         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 417
 418         if (priv)
 419                 priv->hook = NULL;
 420
 421         return (0);
 422 }