1 // SPDX-License-Identifier: (GPL-2.0 OR MPL-1.1)
2 /* src/p80211/p80211conv.c
3 *
4 * Ether/802.11 conversions and packet buffer routines
5 *
6 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
7 * --------------------------------------------------------------------
8 *
9 * linux-wlan
10 *
11 * The contents of this file are subject to the Mozilla Public
12 * License Version 1.1 (the "License"); you may not use this file
13 * except in compliance with the License. You may obtain a copy of
14 * the License at http://www.mozilla.org/MPL/
15 *
16 * Software distributed under the License is distributed on an "AS
17 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
18 * implied. See the License for the specific language governing
19 * rights and limitations under the License.
20 *
21 * Alternatively, the contents of this file may be used under the
22 * terms of the GNU Public License version 2 (the "GPL"), in which
23 * case the provisions of the GPL are applicable instead of the
24 * above. If you wish to allow the use of your version of this file
25 * only under the terms of the GPL and not to allow others to use
26 * your version of this file under the MPL, indicate your decision
27 * by deleting the provisions above and replace them with the notice
28 * and other provisions required by the GPL. If you do not delete
29 * the provisions above, a recipient may use your version of this
30 * file under either the MPL or the GPL.
31 *
32 * --------------------------------------------------------------------
33 *
34 * Inquiries regarding the linux-wlan Open Source project can be
35 * made directly to:
36 *
37 * AbsoluteValue Systems Inc.
38 * info@linux-wlan.com
39 * http://www.linux-wlan.com
40 *
41 * --------------------------------------------------------------------
42 *
43 * Portions of the development of this software were funded by
44 * Intersil Corporation as part of PRISM(R) chipset product development.
45 *
46 * --------------------------------------------------------------------
47 *
48 * This file defines the functions that perform Ethernet to/from
49 * 802.11 frame conversions.
50 *
51 * --------------------------------------------------------------------
52 *
53 *================================================================
54 */
55
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/sched.h>
59 #include <linux/types.h>
60 #include <linux/skbuff.h>
61 #include <linux/slab.h>
62 #include <linux/wireless.h>
63 #include <linux/netdevice.h>
64 #include <linux/etherdevice.h>
65 #include <linux/if_ether.h>
66 #include <linux/byteorder/generic.h>
67
68 #include <asm/byteorder.h>
69
70 #include "p80211types.h"
71 #include "p80211hdr.h"
72 #include "p80211conv.h"
73 #include "p80211mgmt.h"
74 #include "p80211msg.h"
75 #include "p80211netdev.h"
76 #include "p80211ioctl.h"
77 #include "p80211req.h"
78
79 static const u8 oui_rfc1042[] = { 0x00, 0x00, 0x00 };
80 static const u8 oui_8021h[] = { 0x00, 0x00, 0xf8 };
81
82 /*----------------------------------------------------------------
83 * p80211pb_ether_to_80211
84 *
85 * Uses the contents of the ether frame and the etherconv setting
86 * to build the elements of the 802.11 frame.
87 *
88 * We don't actually set
89 * up the frame header here. That's the MAC's job. We're only handling
90 * conversion of DIXII or 802.3+LLC frames to something that works
91 * with 802.11.
92 *
93 * Note -- 802.11 header is NOT part of the skb. Likewise, the 802.11
94 * FCS is also not present and will need to be added elsewhere.
95 *
96 * Arguments:
97 * ethconv Conversion type to perform
98 * skb skbuff containing the ether frame
99 * p80211_hdr 802.11 header
100 *
101 * Returns:
102 * 0 on success, non-zero otherwise
103 *
104 * Call context:
105 * May be called in interrupt or non-interrupt context
106 *----------------------------------------------------------------
107 */
108 int skb_ether_to_p80211(struct wlandevice *wlandev, u32 ethconv,
109 struct sk_buff *skb, union p80211_hdr *p80211_hdr,
110 struct p80211_metawep *p80211_wep)
111 {
112 __le16 fc;
113 u16 proto;
114 struct wlan_ethhdr e_hdr;
115 struct wlan_llc *e_llc;
116 struct wlan_snap *e_snap;
117 int foo;
118
119 memcpy(&e_hdr, skb->data, sizeof(e_hdr));
120
121 if (skb->len <= 0) {
122 pr_debug("zero-length skb!\n");
123 return 1;
124 }
125
126 if (ethconv == WLAN_ETHCONV_ENCAP) { /* simplest case */
127 pr_debug("ENCAP len: %d\n", skb->len);
128 /* here, we don't care what kind of ether frm. Just stick it */
129 /* in the 80211 payload */
130 /* which is to say, leave the skb alone. */
131 } else {
132 /* step 1: classify ether frame, DIX or 802.3? */
133 proto = ntohs(e_hdr.type);
134 if (proto <= ETH_DATA_LEN) {
135 pr_debug("802.3 len: %d\n", skb->len);
136 /* codes <= 1500 reserved for 802.3 lengths */
137 /* it's 802.3, pass ether payload unchanged, */
138
139 /* trim off ethernet header */
140 skb_pull(skb, ETH_HLEN);
141
142 /* leave off any PAD octets. */
143 skb_trim(skb, proto);
144 } else {
145 pr_debug("DIXII len: %d\n", skb->len);
146 /* it's DIXII, time for some conversion */
147
148 /* trim off ethernet header */
149 skb_pull(skb, ETH_HLEN);
150
151 /* tack on SNAP */
152 e_snap = skb_push(skb, sizeof(struct wlan_snap));
153 e_snap->type = htons(proto);
154 if (ethconv == WLAN_ETHCONV_8021h &&
155 p80211_stt_findproto(proto)) {
156 memcpy(e_snap->oui, oui_8021h,
157 WLAN_IEEE_OUI_LEN);
158 } else {
159 memcpy(e_snap->oui, oui_rfc1042,
160 WLAN_IEEE_OUI_LEN);
161 }
162
163 /* tack on llc */
164 e_llc = skb_push(skb, sizeof(struct wlan_llc));
165 e_llc->dsap = 0xAA; /* SNAP, see IEEE 802 */
166 e_llc->ssap = 0xAA;
167 e_llc->ctl = 0x03;
168 }
169 }
170
171 /* Set up the 802.11 header */
172 /* It's a data frame */
173 fc = cpu_to_le16(WLAN_SET_FC_FTYPE(WLAN_FTYPE_DATA) |
174 WLAN_SET_FC_FSTYPE(WLAN_FSTYPE_DATAONLY));
175
176 switch (wlandev->macmode) {
177 case WLAN_MACMODE_IBSS_STA:
178 memcpy(p80211_hdr->a3.a1, &e_hdr.daddr, ETH_ALEN);
179 memcpy(p80211_hdr->a3.a2, wlandev->netdev->dev_addr, ETH_ALEN);
180 memcpy(p80211_hdr->a3.a3, wlandev->bssid, ETH_ALEN);
181 break;
182 case WLAN_MACMODE_ESS_STA:
183 fc |= cpu_to_le16(WLAN_SET_FC_TODS(1));
184 memcpy(p80211_hdr->a3.a1, wlandev->bssid, ETH_ALEN);
185 memcpy(p80211_hdr->a3.a2, wlandev->netdev->dev_addr, ETH_ALEN);
186 memcpy(p80211_hdr->a3.a3, &e_hdr.daddr, ETH_ALEN);
187 break;
188 case WLAN_MACMODE_ESS_AP:
189 fc |= cpu_to_le16(WLAN_SET_FC_FROMDS(1));
190 memcpy(p80211_hdr->a3.a1, &e_hdr.daddr, ETH_ALEN);
191 memcpy(p80211_hdr->a3.a2, wlandev->bssid, ETH_ALEN);
192 memcpy(p80211_hdr->a3.a3, &e_hdr.saddr, ETH_ALEN);
193 break;
194 default:
195 netdev_err(wlandev->netdev,
196 "Error: Converting eth to wlan in unknown mode.\n");
197 return 1;
198 }
199
200 p80211_wep->data = NULL;
201
202 if ((wlandev->hostwep & HOSTWEP_PRIVACYINVOKED) &&
203 (wlandev->hostwep & HOSTWEP_ENCRYPT)) {
204 /* XXXX need to pick keynum other than default? */
205
206 p80211_wep->data = kmalloc(skb->len, GFP_ATOMIC);
207 if (!p80211_wep->data)
208 return -ENOMEM;
209 foo = wep_encrypt(wlandev, skb->data, p80211_wep->data,
210 skb->len,
211 wlandev->hostwep & HOSTWEP_DEFAULTKEY_MASK,
212 p80211_wep->iv, p80211_wep->icv);
213 if (foo) {
214 netdev_warn(wlandev->netdev,
215 "Host en-WEP failed, dropping frame (%d).\n",
216 foo);
217 kfree(p80211_wep->data);
218 return 2;
219 }
220 fc |= cpu_to_le16(WLAN_SET_FC_ISWEP(1));
221 }
222
223 /* skb->nh.raw = skb->data; */
224
225 p80211_hdr->a3.fc = fc;
226 p80211_hdr->a3.dur = 0;
227 p80211_hdr->a3.seq = 0;
228
229 return 0;
230 }
231
232 /* jkriegl: from orinoco, modified */
233 static void orinoco_spy_gather(struct wlandevice *wlandev, char *mac,
234 struct p80211_rxmeta *rxmeta)
235 {
236 int i;
237
238 /* Gather wireless spy statistics: for each packet, compare the
239 * source address with out list, and if match, get the stats...
240 */
241
242 for (i = 0; i < wlandev->spy_number; i++) {
243 if (!memcmp(wlandev->spy_address[i], mac, ETH_ALEN)) {
244 wlandev->spy_stat[i].level = rxmeta->signal;
245 wlandev->spy_stat[i].noise = rxmeta->noise;
246 wlandev->spy_stat[i].qual =
247 (rxmeta->signal >
248 rxmeta->noise) ? (rxmeta->signal -
249 rxmeta->noise) : 0;
250 wlandev->spy_stat[i].updated = 0x7;
251 }
252 }
253 }
254
255 /*----------------------------------------------------------------
256 * p80211pb_80211_to_ether
257 *
258 * Uses the contents of a received 802.11 frame and the etherconv
259 * setting to build an ether frame.
260 *
261 * This function extracts the src and dest address from the 802.11
262 * frame to use in the construction of the eth frame.
263 *
264 * Arguments:
265 * ethconv Conversion type to perform
266 * skb Packet buffer containing the 802.11 frame
267 *
268 * Returns:
269 * 0 on success, non-zero otherwise
270 *
271 * Call context:
272 * May be called in interrupt or non-interrupt context
273 *----------------------------------------------------------------
274 */
275 int skb_p80211_to_ether(struct wlandevice *wlandev, u32 ethconv,
276 struct sk_buff *skb)
277 {
278 struct net_device *netdev = wlandev->netdev;
279 u16 fc;
280 unsigned int payload_length;
281 unsigned int payload_offset;
282 u8 daddr[ETH_ALEN];
283 u8 saddr[ETH_ALEN];
284 union p80211_hdr *w_hdr;
285 struct wlan_ethhdr *e_hdr;
286 struct wlan_llc *e_llc;
287 struct wlan_snap *e_snap;
288
289 int foo;
290
291 payload_length = skb->len - WLAN_HDR_A3_LEN - WLAN_CRC_LEN;
292 payload_offset = WLAN_HDR_A3_LEN;
293
294 w_hdr = (union p80211_hdr *)skb->data;
295
296 /* setup some vars for convenience */
297 fc = le16_to_cpu(w_hdr->a3.fc);
298 if ((WLAN_GET_FC_TODS(fc) == 0) && (WLAN_GET_FC_FROMDS(fc) == 0)) {
299 ether_addr_copy(daddr, w_hdr->a3.a1);
300 ether_addr_copy(saddr, w_hdr->a3.a2);
301 } else if ((WLAN_GET_FC_TODS(fc) == 0) &&
302 (WLAN_GET_FC_FROMDS(fc) == 1)) {
303 ether_addr_copy(daddr, w_hdr->a3.a1);
304 ether_addr_copy(saddr, w_hdr->a3.a3);
305 } else if ((WLAN_GET_FC_TODS(fc) == 1) &&
306 (WLAN_GET_FC_FROMDS(fc) == 0)) {
307 ether_addr_copy(daddr, w_hdr->a3.a3);
308 ether_addr_copy(saddr, w_hdr->a3.a2);
309 } else {
310 payload_offset = WLAN_HDR_A4_LEN;
311 if (payload_length < WLAN_HDR_A4_LEN - WLAN_HDR_A3_LEN) {
312 netdev_err(netdev, "A4 frame too short!\n");
313 return 1;
314 }
315 payload_length -= (WLAN_HDR_A4_LEN - WLAN_HDR_A3_LEN);
316 ether_addr_copy(daddr, w_hdr->a4.a3);
317 ether_addr_copy(saddr, w_hdr->a4.a4);
318 }
319
320 /* perform de-wep if necessary.. */
321 if ((wlandev->hostwep & HOSTWEP_PRIVACYINVOKED) &&
322 WLAN_GET_FC_ISWEP(fc) &&
323 (wlandev->hostwep & HOSTWEP_DECRYPT)) {
324 if (payload_length <= 8) {
325 netdev_err(netdev,
326 "WEP frame too short (%u).\n", skb->len);
327 return 1;
328 }
329 foo = wep_decrypt(wlandev, skb->data + payload_offset + 4,
330 payload_length - 8, -1,
331 skb->data + payload_offset,
332 skb->data + payload_offset +
333 payload_length - 4);
334 if (foo) {
335 /* de-wep failed, drop skb. */
336 pr_debug("Host de-WEP failed, dropping frame (%d).\n",
337 foo);
338 wlandev->rx.decrypt_err++;
339 return 2;
340 }
341
342 /* subtract the IV+ICV length off the payload */
343 payload_length -= 8;
344 /* chop off the IV */
345 skb_pull(skb, 4);
346 /* chop off the ICV. */
347 skb_trim(skb, skb->len - 4);
348
349 wlandev->rx.decrypt++;
350 }
351
352 e_hdr = (struct wlan_ethhdr *)(skb->data + payload_offset);
353
354 e_llc = (struct wlan_llc *)(skb->data + payload_offset);
355 e_snap =
356 (struct wlan_snap *)(skb->data + payload_offset +
357 sizeof(struct wlan_llc));
358
359 /* Test for the various encodings */
360 if ((payload_length >= sizeof(struct wlan_ethhdr)) &&
361 (e_llc->dsap != 0xaa || e_llc->ssap != 0xaa) &&
362 ((!ether_addr_equal_unaligned(daddr, e_hdr->daddr)) ||
363 (!ether_addr_equal_unaligned(saddr, e_hdr->saddr)))) {
364 pr_debug("802.3 ENCAP len: %d\n", payload_length);
365 /* 802.3 Encapsulated */
366 /* Test for an overlength frame */
367 if (payload_length > (netdev->mtu + ETH_HLEN)) {
368 /* A bogus length ethfrm has been encap'd. */
369 /* Is someone trying an oflow attack? */
370 netdev_err(netdev, "ENCAP frame too large (%d > %d)\n",
371 payload_length, netdev->mtu + ETH_HLEN);
372 return 1;
373 }
374
375 /* Chop off the 802.11 header. it's already sane. */
376 skb_pull(skb, payload_offset);
377 /* chop off the 802.11 CRC */
378 skb_trim(skb, skb->len - WLAN_CRC_LEN);
379
380 } else if ((payload_length >= sizeof(struct wlan_llc) +
381 sizeof(struct wlan_snap)) &&
382 (e_llc->dsap == 0xaa) &&
383 (e_llc->ssap == 0xaa) &&
384 (e_llc->ctl == 0x03) &&
385 (((memcmp(e_snap->oui, oui_rfc1042,
386 WLAN_IEEE_OUI_LEN) == 0) &&
387 (ethconv == WLAN_ETHCONV_8021h) &&
388 (p80211_stt_findproto(be16_to_cpu(e_snap->type)))) ||
389 (memcmp(e_snap->oui, oui_rfc1042, WLAN_IEEE_OUI_LEN) !=
390 0))) {
391 pr_debug("SNAP+RFC1042 len: %d\n", payload_length);
392 /* it's a SNAP + RFC1042 frame && protocol is in STT */
393 /* build 802.3 + RFC1042 */
394
395 /* Test for an overlength frame */
396 if (payload_length > netdev->mtu) {
397 /* A bogus length ethfrm has been sent. */
398 /* Is someone trying an oflow attack? */
399 netdev_err(netdev, "SNAP frame too large (%d > %d)\n",
400 payload_length, netdev->mtu);
401 return 1;
402 }
403
404 /* chop 802.11 header from skb. */
405 skb_pull(skb, payload_offset);
406
407 /* create 802.3 header at beginning of skb. */
408 e_hdr = skb_push(skb, ETH_HLEN);
409 ether_addr_copy(e_hdr->daddr, daddr);
410 ether_addr_copy(e_hdr->saddr, saddr);
411 e_hdr->type = htons(payload_length);
412
413 /* chop off the 802.11 CRC */
414 skb_trim(skb, skb->len - WLAN_CRC_LEN);
415
416 } else if ((payload_length >= sizeof(struct wlan_llc) +
417 sizeof(struct wlan_snap)) &&
418 (e_llc->dsap == 0xaa) &&
419 (e_llc->ssap == 0xaa) &&
420 (e_llc->ctl == 0x03)) {
421 pr_debug("802.1h/RFC1042 len: %d\n", payload_length);
422 /* it's an 802.1h frame || (an RFC1042 && protocol not in STT)
423 * build a DIXII + RFC894
424 */
425
426 /* Test for an overlength frame */
427 if ((payload_length - sizeof(struct wlan_llc) -
428 sizeof(struct wlan_snap))
429 > netdev->mtu) {
430 /* A bogus length ethfrm has been sent. */
431 /* Is someone trying an oflow attack? */
432 netdev_err(netdev, "DIXII frame too large (%ld > %d)\n",
433 (long)(payload_length -
434 sizeof(struct wlan_llc) -
435 sizeof(struct wlan_snap)), netdev->mtu);
436 return 1;
437 }
438
439 /* chop 802.11 header from skb. */
440 skb_pull(skb, payload_offset);
441
442 /* chop llc header from skb. */
443 skb_pull(skb, sizeof(struct wlan_llc));
444
445 /* chop snap header from skb. */
446 skb_pull(skb, sizeof(struct wlan_snap));
447
448 /* create 802.3 header at beginning of skb. */
449 e_hdr = skb_push(skb, ETH_HLEN);
450 e_hdr->type = e_snap->type;
451 ether_addr_copy(e_hdr->daddr, daddr);
452 ether_addr_copy(e_hdr->saddr, saddr);
453
454 /* chop off the 802.11 CRC */
455 skb_trim(skb, skb->len - WLAN_CRC_LEN);
456 } else {
457 pr_debug("NON-ENCAP len: %d\n", payload_length);
458 /* any NON-ENCAP */
459 /* it's a generic 80211+LLC or IPX 'Raw 802.3' */
460 /* build an 802.3 frame */
461 /* allocate space and setup hostbuf */
462
463 /* Test for an overlength frame */
464 if (payload_length > netdev->mtu) {
465 /* A bogus length ethfrm has been sent. */
466 /* Is someone trying an oflow attack? */
467 netdev_err(netdev, "OTHER frame too large (%d > %d)\n",
468 payload_length, netdev->mtu);
469 return 1;
470 }
471
472 /* Chop off the 802.11 header. */
473 skb_pull(skb, payload_offset);
474
475 /* create 802.3 header at beginning of skb. */
476 e_hdr = skb_push(skb, ETH_HLEN);
477 ether_addr_copy(e_hdr->daddr, daddr);
478 ether_addr_copy(e_hdr->saddr, saddr);
479 e_hdr->type = htons(payload_length);
480
481 /* chop off the 802.11 CRC */
482 skb_trim(skb, skb->len - WLAN_CRC_LEN);
483 }
484
485 /*
486 * Note that eth_type_trans() expects an skb w/ skb->data pointing
487 * at the MAC header, it then sets the following skb members:
488 * skb->mac_header,
489 * skb->data, and
490 * skb->pkt_type.
491 * It then _returns_ the value that _we're_ supposed to stuff in
492 * skb->protocol. This is nuts.
493 */
494 skb->protocol = eth_type_trans(skb, netdev);
495
496 /* jkriegl: process signal and noise as set in hfa384x_int_rx() */
497 /* jkriegl: only process signal/noise if requested by iwspy */
498 if (wlandev->spy_number)
499 orinoco_spy_gather(wlandev, eth_hdr(skb)->h_source,
500 p80211skb_rxmeta(skb));
501
502 /* Free the metadata */
503 p80211skb_rxmeta_detach(skb);
504
505 return 0;
506 }
507
508 /*----------------------------------------------------------------
509 * p80211_stt_findproto
510 *
511 * Searches the 802.1h Selective Translation Table for a given
512 * protocol.
513 *
514 * Arguments:
515 * proto protocol number (in host order) to search for.
516 *
517 * Returns:
518 * 1 - if the table is empty or a match is found.
519 * 0 - if the table is non-empty and a match is not found.
520 *
521 * Call context:
522 * May be called in interrupt or non-interrupt context
523 *----------------------------------------------------------------
524 */
525 int p80211_stt_findproto(u16 proto)
526 {
527 /* Always return found for now. This is the behavior used by the */
528 /* Zoom Win95 driver when 802.1h mode is selected */
529 /* TODO: If necessary, add an actual search we'll probably
530 * need this to match the CMAC's way of doing things.
531 * Need to do some testing to confirm.
532 */
533
534 if (proto == ETH_P_AARP) /* APPLETALK */
535 return 1;
536
537 return 0;
538 }
539
540 /*----------------------------------------------------------------
541 * p80211skb_rxmeta_detach
542 *
543 * Disconnects the frmmeta and rxmeta from an skb.
544 *
545 * Arguments:
546 * wlandev The wlandev this skb belongs to.
547 * skb The skb we're attaching to.
548 *
549 * Returns:
550 * 0 on success, non-zero otherwise
551 *
552 * Call context:
553 * May be called in interrupt or non-interrupt context
554 *----------------------------------------------------------------
555 */
556 void p80211skb_rxmeta_detach(struct sk_buff *skb)
557 {
558 struct p80211_rxmeta *rxmeta;
559 struct p80211_frmmeta *frmmeta;
560
561 /* Sanity checks */
562 if (!skb) { /* bad skb */
563 pr_debug("Called w/ null skb.\n");
564 return;
565 }
566 frmmeta = p80211skb_frmmeta(skb);
567 if (!frmmeta) { /* no magic */
568 pr_debug("Called w/ bad frmmeta magic.\n");
569 return;
570 }
571 rxmeta = frmmeta->rx;
572 if (!rxmeta) { /* bad meta ptr */
573 pr_debug("Called w/ bad rxmeta ptr.\n");
574 return;
575 }
576
577 /* Free rxmeta */
578 kfree(rxmeta);
579
580 /* Clear skb->cb */
581 memset(skb->cb, 0, sizeof(skb->cb));
582 }
583
584 /*----------------------------------------------------------------
585 * p80211skb_rxmeta_attach
586 *
587 * Allocates a p80211rxmeta structure, initializes it, and attaches
588 * it to an skb.
589 *
590 * Arguments:
591 * wlandev The wlandev this skb belongs to.
592 * skb The skb we're attaching to.
593 *
594 * Returns:
595 * 0 on success, non-zero otherwise
596 *
597 * Call context:
598 * May be called in interrupt or non-interrupt context
599 *----------------------------------------------------------------
600 */
601 int p80211skb_rxmeta_attach(struct wlandevice *wlandev, struct sk_buff *skb)
602 {
603 int result = 0;
604 struct p80211_rxmeta *rxmeta;
605 struct p80211_frmmeta *frmmeta;
606
607 /* If these already have metadata, we error out! */
608 if (p80211skb_rxmeta(skb)) {
609 netdev_err(wlandev->netdev,
610 "%s: RXmeta already attached!\n", wlandev->name);
611 result = 0;
612 goto exit;
613 }
614
615 /* Allocate the rxmeta */
616 rxmeta = kzalloc(sizeof(*rxmeta), GFP_ATOMIC);
617
618 if (!rxmeta) {
619 result = 1;
620 goto exit;
621 }
622
623 /* Initialize the rxmeta */
624 rxmeta->wlandev = wlandev;
625 rxmeta->hosttime = jiffies;
626
627 /* Overlay a frmmeta_t onto skb->cb */
628 memset(skb->cb, 0, sizeof(struct p80211_frmmeta));
629 frmmeta = (struct p80211_frmmeta *)(skb->cb);
630 frmmeta->magic = P80211_FRMMETA_MAGIC;
631 frmmeta->rx = rxmeta;
632 exit:
633 return result;
634 }
635
636 /*----------------------------------------------------------------
637 * p80211skb_free
638 *
639 * Frees an entire p80211skb by checking and freeing the meta struct
640 * and then freeing the skb.
641 *
642 * Arguments:
643 * wlandev The wlandev this skb belongs to.
644 * skb The skb we're attaching to.
645 *
646 * Returns:
647 * 0 on success, non-zero otherwise
648 *
649 * Call context:
650 * May be called in interrupt or non-interrupt context
651 *----------------------------------------------------------------
652 */
653 void p80211skb_free(struct wlandevice *wlandev, struct sk_buff *skb)
654 {
655 struct p80211_frmmeta *meta;
656
657 meta = p80211skb_frmmeta(skb);
658 if (meta && meta->rx)
659 p80211skb_rxmeta_detach(skb);
660 else
661 netdev_err(wlandev->netdev,
662 "Freeing an skb (%p) w/ no frmmeta.\n", skb);
663 dev_kfree_skb(skb);
664 }