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