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