kernel/netgraph7: Replace usage of MALLOC/FREE with kmalloc/kfree here too.
[dragonfly.git] / sys / netgraph7 / ng_atmllc.c
1 /*-
2  * Copyright (c) 2003-2004 Benno Rice <benno@eloquent.com.au>
3  * All Rights Reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR  BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/netgraph/ng_atmllc.c,v 1.3 2005/01/07 01:45:39 imp Exp $
27  * $DragonFly: src/sys/netgraph7/ng_atmllc.c,v 1.2 2008/06/26 23:05:35 dillon Exp $
28  */
29
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/malloc.h>
34 #include <sys/mbuf.h>
35 #include <sys/socket.h>
36 #include <sys/sockio.h>
37
38 #include "ng_message.h"
39 #include "netgraph.h"
40 #include "ng_atmllc.h"
41
42 #include <net/if.h>
43 #include <net/ethernet.h>       /* for M_HASFCS and ETHER_HDR_LEN */
44 #include <net/if_atm.h>         /* for struct atmllc */
45
46 #define NG_ATMLLC_HEADER                "\252\252\3\0\200\302"
47 #define NG_ATMLLC_HEADER_LEN            (sizeof(struct atmllc))
48 #define NG_ATMLLC_TYPE_ETHERNET_FCS     0x0001
49 #define NG_ATMLLC_TYPE_FDDI_FCS         0x0004
50 #define NG_ATMLLC_TYPE_ETHERNET_NOFCS   0x0007
51 #define NG_ATMLLC_TYPE_FDDI_NOFCS       0x000A
52
53 struct ng_atmllc_priv {
54         hook_p          atm;
55         hook_p          ether;
56         hook_p          fddi;
57 };
58
59 /* Netgraph methods. */
60 static ng_constructor_t         ng_atmllc_constructor;
61 static ng_shutdown_t            ng_atmllc_shutdown;
62 static ng_rcvmsg_t              ng_atmllc_rcvmsg;
63 static ng_newhook_t             ng_atmllc_newhook;
64 static ng_rcvdata_t             ng_atmllc_rcvdata;
65 static ng_disconnect_t          ng_atmllc_disconnect;
66
67 static struct ng_type ng_atmllc_typestruct = {
68         .version =      NG_ABI_VERSION, 
69         .name =         NG_ATMLLC_NODE_TYPE,
70         .constructor =  ng_atmllc_constructor,
71         .rcvmsg =       ng_atmllc_rcvmsg,
72         .shutdown =     ng_atmllc_shutdown,
73         .newhook =      ng_atmllc_newhook,
74         .rcvdata =      ng_atmllc_rcvdata,
75         .disconnect =   ng_atmllc_disconnect,
76 };
77 NETGRAPH_INIT(atmllc, &ng_atmllc_typestruct);
78
79 static int
80 ng_atmllc_constructor(node_p node)
81 {
82         struct  ng_atmllc_priv *priv;
83
84         priv = kmalloc(sizeof(*priv), M_NETGRAPH,
85                        M_WAITOK | M_NULLOK | M_ZERO);
86         if (priv == NULL) {
87                 return (ENOMEM);
88         }
89
90         NG_NODE_SET_PRIVATE(node, priv);
91
92         return (0);
93 }
94
95 static int
96 ng_atmllc_rcvmsg(node_p node, item_p item, hook_p lasthook)
97 {
98         struct  ng_mesg *msg;
99         int     error;
100
101         error = 0;
102         NGI_GET_MSG(item, msg);
103         msg->header.flags |= NGF_RESP;
104         NG_RESPOND_MSG(error, node, item, msg);
105         return (error);
106 }
107
108 static int
109 ng_atmllc_shutdown(node_p node)
110 {
111         struct  ng_atmllc_priv *priv;
112
113         priv = NG_NODE_PRIVATE(node);
114
115         kfree(priv, M_NETGRAPH);
116
117         NG_NODE_UNREF(node);
118
119         return (0);
120 }
121
122 static int
123 ng_atmllc_newhook(node_p node, hook_p hook, const char *name)
124 {
125         struct  ng_atmllc_priv *priv;
126
127         priv = NG_NODE_PRIVATE(node);
128
129         if (strcmp(name, NG_ATMLLC_HOOK_ATM) == 0) {
130                 if (priv->atm != NULL) {
131                         return (EISCONN);
132                 }
133                 priv->atm = hook;
134         } else if (strcmp(name, NG_ATMLLC_HOOK_ETHER) == 0) {
135                 if (priv->ether != NULL) {
136                         return (EISCONN);
137                 }
138                 priv->ether = hook;
139         } else if (strcmp(name, NG_ATMLLC_HOOK_FDDI) == 0) {
140                 if (priv->fddi != NULL) {
141                         return (EISCONN);
142                 }
143                 priv->fddi = hook;
144         } else {
145                 return (EINVAL);
146         }
147
148         return (0);
149 }
150
151 static int
152 ng_atmllc_rcvdata(hook_p hook, item_p item)
153 {
154         struct  ng_atmllc_priv *priv;
155         struct  mbuf *m;
156         struct  atmllc *hdr;
157         hook_p  outhook;
158         u_int   padding;
159         int     error;
160
161         priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
162         m = NGI_M(item);
163         outhook = NULL;
164         padding = 0;
165
166         if (hook == priv->atm) {
167                 /* Ditch the psuedoheader. */
168                 hdr = mtod(m, struct atmllc *);
169                 /* m_adj(m, sizeof(struct atm_pseudohdr)); */
170
171                 /*
172                  * Make sure we have the LLC and ethernet headers.
173                  * The ethernet header size is slightly larger than the FDDI
174                  * header, which is convenient.
175                  */
176                 if (m->m_len < sizeof(struct atmllc) + ETHER_HDR_LEN) {
177                         m = m_pullup(m, sizeof(struct atmllc) + ETHER_HDR_LEN);
178                         if (m == NULL) {
179                                 return (ENOMEM);
180                         }
181                 }
182
183                 /* Decode the LLC header. */
184                 hdr = mtod(m, struct atmllc *);
185                 if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_ETHERNET_NOFCS) {
186                         m->m_flags &= ~M_HASFCS;
187                         outhook = priv->ether;
188                         padding = 2;
189                 } else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_ETHERNET_FCS) {
190                         m->m_flags |= M_HASFCS;
191                         outhook = priv->ether;
192                         padding = 2;
193                 } else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_FDDI_NOFCS) {
194                         m->m_flags &= ~M_HASFCS;
195                         outhook = priv->fddi;
196                         padding = 3;
197                 } else if (ATM_LLC_TYPE(hdr) == NG_ATMLLC_TYPE_FDDI_FCS) {
198                         m->m_flags |= M_HASFCS;
199                         outhook = priv->fddi;
200                         padding = 3;
201                 } else {
202                         printf("ng_atmllc: unknown type: %x\n",
203                             ATM_LLC_TYPE(hdr));
204                 }
205
206                 /* Remove the LLC header and any padding*/
207                 m_adj(m, sizeof(struct atmllc) + padding);
208         } else if (hook == priv->ether) {
209                 /* Add the LLC header */
210                 M_PREPEND(m, NG_ATMLLC_HEADER_LEN + 2, MB_DONTWAIT);
211                 if (m == NULL) {
212                         printf("ng_atmllc: M_PREPEND failed\n");
213                         NG_FREE_ITEM(item);
214                         return (ENOMEM);
215                 }
216                 hdr = mtod(m, struct atmllc *);
217                 bzero((void *)hdr, sizeof(struct atmllc) + 2);
218                 bcopy(NG_ATMLLC_HEADER, hdr->llchdr, 6);
219                 if ((m->m_flags & M_HASFCS) != 0) {
220                         ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_ETHERNET_FCS);
221                 } else {
222                         ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_ETHERNET_NOFCS);
223                 }
224                 outhook = priv->atm;
225         } else if (hook == priv->fddi) {
226                 /* Add the LLC header */
227                 M_PREPEND(m, NG_ATMLLC_HEADER_LEN + 3, MB_DONTWAIT);
228                 if (m == NULL) {
229                         printf("ng_atmllc: M_PREPEND failed\n");
230                         NG_FREE_ITEM(item);
231                         return (ENOMEM);
232                 }
233                 hdr = mtod(m, struct atmllc *);
234                 bzero((void *)hdr, sizeof(struct atmllc) + 3);
235                 bcopy(NG_ATMLLC_HEADER, hdr->llchdr, 6);
236                 if ((m->m_flags & M_HASFCS) != 0) {
237                         ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_FDDI_FCS);
238                 } else {
239                         ATM_LLC_SETTYPE(hdr, NG_ATMLLC_TYPE_FDDI_NOFCS);
240                 }
241                 outhook = priv->atm;
242         }
243
244         if (outhook == NULL) {
245                 NG_FREE_ITEM(item);
246                 return (0);
247         }
248
249         NG_FWD_NEW_DATA(error, item, outhook, m);
250         return (error);
251 }
252
253 static int
254 ng_atmllc_disconnect(hook_p hook)
255 {
256         node_p  node;
257         struct  ng_atmllc_priv *priv;
258
259         node = NG_HOOK_NODE(hook);
260         priv = NG_NODE_PRIVATE(node);
261
262         if (hook == priv->atm) {
263                 priv->atm = NULL;
264         } else if (hook == priv->ether) {
265                 priv->ether = NULL;
266         } else if (hook == priv->fddi) {
267                 priv->fddi = NULL;
268         }
269
270         if (NG_NODE_NUMHOOKS(node) == 0 && NG_NODE_IS_VALID(node)) {
271                 ng_rmnode_self(node);
272         }
273
274         return (0);
275 }