?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Btrfs: device_list_add() should not update list when mounted
[linux/fpc-iii.git] / drivers / staging / vt6655 / key.c
blob09a8bf50527bbc38d9f003fc099e876cd6e40c8c
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 *
20 * File: key.c
21 *
22 * Purpose: Implement functions for 802.11i Key management
23 *
24 * Author: Jerry Chen
25 *
26 * Date: May 29, 2003
27 *
28 * Functions:
29 * KeyvInitTable - Init Key management table
30 * KeybGetKey - Get Key from table
31 * KeybSetKey - Set Key to table
32 * KeybRemoveKey - Remove Key from table
33 * KeybGetTransmitKey - Get Transmit Key from table
34 *
35 * Revision History:
36 *
37 */
38
39 #include "tmacro.h"
40 #include "key.h"
41 #include "mac.h"
42
43 /*--------------------- Static Definitions -------------------------*/
44
45 /*--------------------- Static Classes ----------------------------*/
46
47 /*--------------------- Static Variables --------------------------*/
48 static int msglevel = MSG_LEVEL_INFO;
49 /*--------------------- Static Functions --------------------------*/
50
51 /*--------------------- Export Variables --------------------------*/
52
53 /*--------------------- Static Definitions -------------------------*/
54
55 /*--------------------- Static Classes ----------------------------*/
56
57 /*--------------------- Static Variables --------------------------*/
58
59 /*--------------------- Static Functions --------------------------*/
60 static void
61 s_vCheckKeyTableValid(PSKeyManagement pTable, unsigned long dwIoBase)
62 {
63 int i;
64
65 for (i = 0; i < MAX_KEY_TABLE; i++) {
66 if (pTable->KeyTable[i].bInUse &&
67 !pTable->KeyTable[i].PairwiseKey.bKeyValid &&
68 !pTable->KeyTable[i].GroupKey[0].bKeyValid &&
69 !pTable->KeyTable[i].GroupKey[1].bKeyValid &&
70 !pTable->KeyTable[i].GroupKey[2].bKeyValid &&
71 !pTable->KeyTable[i].GroupKey[3].bKeyValid) {
72 pTable->KeyTable[i].bInUse = false;
73 pTable->KeyTable[i].wKeyCtl = 0;
74 pTable->KeyTable[i].bSoftWEP = false;
75 MACvDisableKeyEntry(dwIoBase, i);
76 }
77 }
78 }
79
80 /*--------------------- Export Functions --------------------------*/
81
82 /*
83 * Description: Init Key management table
84 *
85 * Parameters:
86 * In:
87 * pTable - Pointer to Key table
88 * Out:
89 * none
90 *
91 * Return Value: none
92 *
93 */
94 void KeyvInitTable(PSKeyManagement pTable, unsigned long dwIoBase)
95 {
96 int i;
97 int jj;
98
99 for (i = 0; i < MAX_KEY_TABLE; i++) {
100 pTable->KeyTable[i].bInUse = false;
101 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
102 pTable->KeyTable[i].PairwiseKey.pvKeyTable = (void *)&pTable->KeyTable[i];
103 for (jj = 0; jj < MAX_GROUP_KEY; jj++) {
104 pTable->KeyTable[i].GroupKey[jj].bKeyValid = false;
105 pTable->KeyTable[i].GroupKey[jj].pvKeyTable = (void *)&pTable->KeyTable[i];
106 }
107 pTable->KeyTable[i].wKeyCtl = 0;
108 pTable->KeyTable[i].dwGTKeyIndex = 0;
109 pTable->KeyTable[i].bSoftWEP = false;
110 MACvDisableKeyEntry(dwIoBase, i);
111 }
112 }
113
114 /*
115 * Description: Get Key from table
116 *
117 * Parameters:
118 * In:
119 * pTable - Pointer to Key table
120 * pbyBSSID - BSSID of Key
121 * dwKeyIndex - Key Index (0xFFFFFFFF means pairwise key)
122 * Out:
123 * pKey - Key return
124 *
125 * Return Value: true if found otherwise false
126 *
127 */
128 bool KeybGetKey(
129 PSKeyManagement pTable,
130 unsigned char *pbyBSSID,
131 unsigned long dwKeyIndex,
132 PSKeyItem *pKey
133 )
134 {
135 int i;
136
137 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybGetKey() \n");
138
139 *pKey = NULL;
140 for (i = 0; i < MAX_KEY_TABLE; i++) {
141 if (pTable->KeyTable[i].bInUse &&
142 ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
143 if (dwKeyIndex == 0xFFFFFFFF) {
144 if (pTable->KeyTable[i].PairwiseKey.bKeyValid) {
145 *pKey = &(pTable->KeyTable[i].PairwiseKey);
146 return true;
147 } else {
148 return false;
149 }
150 } else if (dwKeyIndex < MAX_GROUP_KEY) {
151 if (pTable->KeyTable[i].GroupKey[dwKeyIndex].bKeyValid) {
152 *pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex]);
153 return true;
154 } else {
155 return false;
156 }
157 } else {
158 return false;
159 }
160 }
161 }
162 return false;
163 }
164
165 /*
166 * Description: Set Key to table
167 *
168 * Parameters:
169 * In:
170 * pTable - Pointer to Key table
171 * pbyBSSID - BSSID of Key
172 * dwKeyIndex - Key index (reference to NDIS DDK)
173 * uKeyLength - Key length
174 * KeyRSC - Key RSC
175 * pbyKey - Pointer to key
176 * Out:
177 * none
178 *
179 * Return Value: true if success otherwise false
180 *
181 */
182 bool KeybSetKey(
183 PSKeyManagement pTable,
184 unsigned char *pbyBSSID,
185 unsigned long dwKeyIndex,
186 unsigned long uKeyLength,
187 PQWORD pKeyRSC,
188 unsigned char *pbyKey,
189 unsigned char byKeyDecMode,
190 unsigned long dwIoBase,
191 unsigned char byLocalID
192 )
193 {
194 int i, j;
195 unsigned int ii;
196 PSKeyItem pKey;
197 unsigned int uKeyIdx;
198
199 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enter KeybSetKey: %lX\n", dwKeyIndex);
200
201 j = (MAX_KEY_TABLE-1);
202 for (i = 0; i < (MAX_KEY_TABLE - 1); i++) {
203 if (!pTable->KeyTable[i].bInUse && (j == (MAX_KEY_TABLE-1))) {
204 // found empty table
205 j = i;
206 }
207 if (pTable->KeyTable[i].bInUse &&
208 ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
209 // found table already exist
210 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
211 // Pairwise key
212 pKey = &(pTable->KeyTable[i].PairwiseKey);
213 pTable->KeyTable[i].wKeyCtl &= 0xFFF0; // clear pairwise key control filed
214 pTable->KeyTable[i].wKeyCtl |= byKeyDecMode;
215 uKeyIdx = 4; // use HW key entry 4 for pairwise key
216 } else {
217 // Group key
218 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
219 return false;
220 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
221 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
222 // Group transmit key
223 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
224 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[i].dwGTKeyIndex, i);
225 }
226 pTable->KeyTable[i].wKeyCtl &= 0xFF0F; // clear group key control filed
227 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
228 pTable->KeyTable[i].wKeyCtl |= 0x0040; // use group key for group address
229 uKeyIdx = (dwKeyIndex & 0x000000FF);
230 }
231 pTable->KeyTable[i].wKeyCtl |= 0x8000; // enable on-fly
232
233 pKey->bKeyValid = true;
234 pKey->uKeyLength = uKeyLength;
235 pKey->dwKeyIndex = dwKeyIndex;
236 pKey->byCipherSuite = byKeyDecMode;
237 memcpy(pKey->abyKey, pbyKey, uKeyLength);
238 if (byKeyDecMode == KEY_CTL_WEP) {
239 if (uKeyLength == WLAN_WEP40_KEYLEN)
240 pKey->abyKey[15] &= 0x7F;
241 if (uKeyLength == WLAN_WEP104_KEYLEN)
242 pKey->abyKey[15] |= 0x80;
243 }
244 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pbyBSSID, (u32 *)pKey->abyKey, byLocalID);
245
246 if ((dwKeyIndex & USE_KEYRSC) == 0) {
247 // RSC set by NIC
248 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
249 } else {
250 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
251 }
252 pKey->dwTSC47_16 = 0;
253 pKey->wTSC15_0 = 0;
254
255 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybSetKey(R): \n");
256 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->bKeyValid: %d\n ", pKey->bKeyValid);
257 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->abyKey: ");
258 for (ii = 0; ii < pKey->uKeyLength; ii++)
259 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
260
261 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
262
263 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
264 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
265 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
266
267 return true;
268 }
269 }
270 if (j < (MAX_KEY_TABLE-1)) {
271 memcpy(pTable->KeyTable[j].abyBSSID, pbyBSSID, ETH_ALEN);
272 pTable->KeyTable[j].bInUse = true;
273 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
274 // Pairwise key
275 pKey = &(pTable->KeyTable[j].PairwiseKey);
276 pTable->KeyTable[j].wKeyCtl &= 0xFFF0; // clear pairwise key control filed
277 pTable->KeyTable[j].wKeyCtl |= byKeyDecMode;
278 uKeyIdx = 4; // use HW key entry 4 for pairwise key
279 } else {
280 // Group key
281 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
282 return false;
283 pKey = &(pTable->KeyTable[j].GroupKey[dwKeyIndex & 0x000000FF]);
284 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
285 // Group transmit key
286 pTable->KeyTable[j].dwGTKeyIndex = dwKeyIndex;
287 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Group transmit key(N)[%lX]: %d\n", pTable->KeyTable[j].dwGTKeyIndex, j);
288 }
289 pTable->KeyTable[j].wKeyCtl &= 0xFF0F; // clear group key control filed
290 pTable->KeyTable[j].wKeyCtl |= (byKeyDecMode << 4);
291 pTable->KeyTable[j].wKeyCtl |= 0x0040; // use group key for group address
292 uKeyIdx = (dwKeyIndex & 0x000000FF);
293 }
294 pTable->KeyTable[j].wKeyCtl |= 0x8000; // enable on-fly
295
296 pKey->bKeyValid = true;
297 pKey->uKeyLength = uKeyLength;
298 pKey->dwKeyIndex = dwKeyIndex;
299 pKey->byCipherSuite = byKeyDecMode;
300 memcpy(pKey->abyKey, pbyKey, uKeyLength);
301 if (byKeyDecMode == KEY_CTL_WEP) {
302 if (uKeyLength == WLAN_WEP40_KEYLEN)
303 pKey->abyKey[15] &= 0x7F;
304 if (uKeyLength == WLAN_WEP104_KEYLEN)
305 pKey->abyKey[15] |= 0x80;
306 }
307 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[j].wKeyCtl, j, uKeyIdx, pbyBSSID, (u32 *)pKey->abyKey, byLocalID);
308
309 if ((dwKeyIndex & USE_KEYRSC) == 0) {
310 // RSC set by NIC
311 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
312 } else {
313 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
314 }
315 pKey->dwTSC47_16 = 0;
316 pKey->wTSC15_0 = 0;
317
318 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybSetKey(N): \n");
319 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->bKeyValid: %d\n ", pKey->bKeyValid);
320 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
321 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->abyKey: ");
322 for (ii = 0; ii < pKey->uKeyLength; ii++)
323 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
324
325 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
326
327 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
328 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
329 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
330
331 return true;
332 }
333 return false;
334 }
335
336 /*
337 * Description: Remove Key from table
338 *
339 * Parameters:
340 * In:
341 * pTable - Pointer to Key table
342 * pbyBSSID - BSSID of Key
343 * dwKeyIndex - Key Index (reference to NDIS DDK)
344 * Out:
345 * none
346 *
347 * Return Value: true if success otherwise false
348 *
349 */
350 bool KeybRemoveKey(
351 PSKeyManagement pTable,
352 unsigned char *pbyBSSID,
353 unsigned long dwKeyIndex,
354 unsigned long dwIoBase
355 )
356 {
357 int i;
358
359 if (is_broadcast_ether_addr(pbyBSSID)) {
360 // delete all keys
361 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
362 for (i = 0; i < MAX_KEY_TABLE; i++)
363 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
364
365 s_vCheckKeyTableValid(pTable, dwIoBase);
366 return true;
367 } else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
368 for (i = 0; i < MAX_KEY_TABLE; i++) {
369 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = false;
370 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
371 // remove Group transmit key
372 pTable->KeyTable[i].dwGTKeyIndex = 0;
373 }
374 }
375 s_vCheckKeyTableValid(pTable, dwIoBase);
376 return true;
377 } else {
378 return false;
379 }
380 }
381
382 for (i = 0; i < MAX_KEY_TABLE; i++) {
383 if (pTable->KeyTable[i].bInUse &&
384 ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
385 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
386 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
387 s_vCheckKeyTableValid(pTable, dwIoBase);
388 return true;
389 } else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
390 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = false;
391 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
392 // remove Group transmit key
393 pTable->KeyTable[i].dwGTKeyIndex = 0;
394 }
395 s_vCheckKeyTableValid(pTable, dwIoBase);
396 return true;
397 } else {
398 return false;
399 }
400 }
401 }
402 return false;
403 }
404
405 /*
406 * Description: Remove Key from table
407 *
408 * Parameters:
409 * In:
410 * pTable - Pointer to Key table
411 * pbyBSSID - BSSID of Key
412 * Out:
413 * none
414 *
415 * Return Value: true if success otherwise false
416 *
417 */
418 bool KeybRemoveAllKey(
419 PSKeyManagement pTable,
420 unsigned char *pbyBSSID,
421 unsigned long dwIoBase
422 )
423 {
424 int i, u;
425
426 for (i = 0; i < MAX_KEY_TABLE; i++) {
427 if (pTable->KeyTable[i].bInUse &&
428 ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
429 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
430 for (u = 0; u < MAX_GROUP_KEY; u++)
431 pTable->KeyTable[i].GroupKey[u].bKeyValid = false;
432
433 pTable->KeyTable[i].dwGTKeyIndex = 0;
434 s_vCheckKeyTableValid(pTable, dwIoBase);
435 return true;
436 }
437 }
438 return false;
439 }
440
441 /*
442 * Description: Remove WEP Key from table
443 *
444 * Parameters:
445 * In:
446 * pTable - Pointer to Key table
447 * Out:
448 * none
449 *
450 * Return Value: true if success otherwise false
451 *
452 */
453 void KeyvRemoveWEPKey(
454 PSKeyManagement pTable,
455 unsigned long dwKeyIndex,
456 unsigned long dwIoBase
457 )
458 {
459 if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
460 if (pTable->KeyTable[MAX_KEY_TABLE-1].bInUse) {
461 if (pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].byCipherSuite == KEY_CTL_WEP) {
462 pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = false;
463 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex & 0x7FFFFFFF)) {
464 // remove Group transmit key
465 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = 0;
466 }
467 }
468 }
469 s_vCheckKeyTableValid(pTable, dwIoBase);
470 }
471 return;
472 }
473
474 void KeyvRemoveAllWEPKey(
475 PSKeyManagement pTable,
476 unsigned long dwIoBase
477 )
478 {
479 int i;
480
481 for (i = 0; i < MAX_GROUP_KEY; i++)
482 KeyvRemoveWEPKey(pTable, i, dwIoBase);
483 }
484
485 /*
486 * Description: Get Transmit Key from table
487 *
488 * Parameters:
489 * In:
490 * pTable - Pointer to Key table
491 * pbyBSSID - BSSID of Key
492 * Out:
493 * pKey - Key return
494 *
495 * Return Value: true if found otherwise false
496 *
497 */
498 bool KeybGetTransmitKey(
499 PSKeyManagement pTable,
500 unsigned char *pbyBSSID,
501 unsigned long dwKeyType,
502 PSKeyItem *pKey
503 )
504 {
505 int i, ii;
506
507 *pKey = NULL;
508 for (i = 0; i < MAX_KEY_TABLE; i++) {
509 if (pTable->KeyTable[i].bInUse &&
510 ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
511 if (dwKeyType == PAIRWISE_KEY) {
512 if (pTable->KeyTable[i].PairwiseKey.bKeyValid) {
513 *pKey = &(pTable->KeyTable[i].PairwiseKey);
514
515 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybGetTransmitKey:");
516 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PAIRWISE_KEY: KeyTable.abyBSSID: ");
517 for (ii = 0; ii < 6; ii++)
518 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%x ", pTable->KeyTable[i].abyBSSID[ii]);
519
520 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
521
522 return true;
523 } else {
524 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PairwiseKey.bKeyValid == false\n");
525 return false;
526 }
527 } // End of Type == PAIRWISE
528 else {
529 if (pTable->KeyTable[i].dwGTKeyIndex == 0) {
530 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ERROR: dwGTKeyIndex == 0 !!!\n");
531 return false;
532 }
533 if (pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)].bKeyValid) {
534 *pKey = &(pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)]);
535
536 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybGetTransmitKey:");
537 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP_KEY: KeyTable.abyBSSID\n");
538 for (ii = 0; ii < 6; ii++)
539 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%x ", pTable->KeyTable[i].abyBSSID[ii]);
540
541 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
542 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwGTKeyIndex: %lX\n", pTable->KeyTable[i].dwGTKeyIndex);
543
544 return true;
545 } else {
546 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GroupKey.bKeyValid == false\n");
547 return false;
548 }
549 } // End of Type = GROUP
550 } // BSSID match
551 }
552 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ERROR: NO Match BSSID !!! ");
553 for (ii = 0; ii < 6; ii++)
554 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", *(pbyBSSID+ii));
555
556 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
557 return false;
558 }
559
560 /*
561 * Description: Check Pairewise Key
562 *
563 * Parameters:
564 * In:
565 * pTable - Pointer to Key table
566 * Out:
567 * none
568 *
569 * Return Value: true if found otherwise false
570 *
571 */
572 bool KeybCheckPairewiseKey(
573 PSKeyManagement pTable,
574 PSKeyItem *pKey
575 )
576 {
577 int i;
578
579 *pKey = NULL;
580 for (i = 0; i < MAX_KEY_TABLE; i++) {
581 if (pTable->KeyTable[i].bInUse &&
582 pTable->KeyTable[i].PairwiseKey.bKeyValid) {
583 *pKey = &(pTable->KeyTable[i].PairwiseKey);
584 return true;
585 }
586 }
587 return false;
588 }
589
590 /*
591 * Description: Set Key to table
592 *
593 * Parameters:
594 * In:
595 * pTable - Pointer to Key table
596 * dwKeyIndex - Key index (reference to NDIS DDK)
597 * uKeyLength - Key length
598 * KeyRSC - Key RSC
599 * pbyKey - Pointer to key
600 * Out:
601 * none
602 *
603 * Return Value: true if success otherwise false
604 *
605 */
606 bool KeybSetDefaultKey(
607 PSKeyManagement pTable,
608 unsigned long dwKeyIndex,
609 unsigned long uKeyLength,
610 PQWORD pKeyRSC,
611 unsigned char *pbyKey,
612 unsigned char byKeyDecMode,
613 unsigned long dwIoBase,
614 unsigned char byLocalID
615 )
616 {
617 unsigned int ii;
618 PSKeyItem pKey;
619 unsigned int uKeyIdx;
620
621 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enter KeybSetDefaultKey: %1x, %d \n", (int)dwKeyIndex, (int)uKeyLength);
622
623 if ((dwKeyIndex & PAIRWISE_KEY) != 0) // Pairwise key
624 return false;
625 else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
626 return false;
627
628 if (uKeyLength > MAX_KEY_LEN)
629 return false;
630
631 pTable->KeyTable[MAX_KEY_TABLE - 1].bInUse = true;
632 for (ii = 0; ii < ETH_ALEN; ii++)
633 pTable->KeyTable[MAX_KEY_TABLE - 1].abyBSSID[ii] = 0xFF;
634
635 // Group key
636 pKey = &(pTable->KeyTable[MAX_KEY_TABLE - 1].GroupKey[dwKeyIndex & 0x000000FF]);
637 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
638 // Group transmit key
639 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = dwKeyIndex;
640 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex, MAX_KEY_TABLE-1);
641
642 }
643 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl &= 0x7F00; // clear all key control filed
644 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode << 4);
645 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode);
646 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x0044; // use group key for all address
647 uKeyIdx = (dwKeyIndex & 0x000000FF);
648
649 if ((uKeyLength == WLAN_WEP232_KEYLEN) &&
650 (byKeyDecMode == KEY_CTL_WEP)) {
651 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x4000; // disable on-fly disable address match
652 pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP = true;
653 } else {
654 if (!pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP)
655 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0xC000; // enable on-fly disable address match
656 }
657
658 pKey->bKeyValid = true;
659 pKey->uKeyLength = uKeyLength;
660 pKey->dwKeyIndex = dwKeyIndex;
661 pKey->byCipherSuite = byKeyDecMode;
662 memcpy(pKey->abyKey, pbyKey, uKeyLength);
663 if (byKeyDecMode == KEY_CTL_WEP) {
664 if (uKeyLength == WLAN_WEP40_KEYLEN)
665 pKey->abyKey[15] &= 0x7F;
666 if (uKeyLength == WLAN_WEP104_KEYLEN)
667 pKey->abyKey[15] |= 0x80;
668 }
669 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl, MAX_KEY_TABLE-1, uKeyIdx, pTable->KeyTable[MAX_KEY_TABLE-1].abyBSSID, (u32 *)pKey->abyKey, byLocalID);
670
671 if ((dwKeyIndex & USE_KEYRSC) == 0) {
672 // RSC set by NIC
673 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
674 } else {
675 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
676 }
677 pKey->dwTSC47_16 = 0;
678 pKey->wTSC15_0 = 0;
679
680 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybSetKey(R): \n");
681 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->bKeyValid: %d\n", pKey->bKeyValid);
682 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->uKeyLength: %d\n", (int)pKey->uKeyLength);
683 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->abyKey: \n");
684 for (ii = 0; ii < pKey->uKeyLength; ii++)
685 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%x", pKey->abyKey[ii]);
686
687 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
688
689 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->dwTSC47_16: %lx\n", pKey->dwTSC47_16);
690 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->wTSC15_0: %x\n", pKey->wTSC15_0);
691 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->dwKeyIndex: %lx\n", pKey->dwKeyIndex);
692
693 return true;
694 }
695
696 /*
697 * Description: Set Key to table
698 *
699 * Parameters:
700 * In:
701 * pTable - Pointer to Key table
702 * dwKeyIndex - Key index (reference to NDIS DDK)
703 * uKeyLength - Key length
704 * KeyRSC - Key RSC
705 * pbyKey - Pointer to key
706 * Out:
707 * none
708 *
709 * Return Value: true if success otherwise false
710 *
711 */
712 bool KeybSetAllGroupKey(
713 PSKeyManagement pTable,
714 unsigned long dwKeyIndex,
715 unsigned long uKeyLength,
716 PQWORD pKeyRSC,
717 unsigned char *pbyKey,
718 unsigned char byKeyDecMode,
719 unsigned long dwIoBase,
720 unsigned char byLocalID
721 )
722 {
723 int i;
724 unsigned int ii;
725 PSKeyItem pKey;
726 unsigned int uKeyIdx;
727
728 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enter KeybSetAllGroupKey: %lX\n", dwKeyIndex);
729
730 if ((dwKeyIndex & PAIRWISE_KEY) != 0) // Pairwise key
731 return false;
732 else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
733 return false;
734
735 for (i = 0; i < MAX_KEY_TABLE - 1; i++) {
736 if (pTable->KeyTable[i].bInUse) {
737 // found table already exist
738 // Group key
739 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
740 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
741 // Group transmit key
742 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
743 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[i].dwGTKeyIndex, i);
744
745 }
746 pTable->KeyTable[i].wKeyCtl &= 0xFF0F; // clear group key control filed
747 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
748 pTable->KeyTable[i].wKeyCtl |= 0x0040; // use group key for group address
749 uKeyIdx = (dwKeyIndex & 0x000000FF);
750
751 pTable->KeyTable[i].wKeyCtl |= 0x8000; // enable on-fly
752
753 pKey->bKeyValid = true;
754 pKey->uKeyLength = uKeyLength;
755 pKey->dwKeyIndex = dwKeyIndex;
756 pKey->byCipherSuite = byKeyDecMode;
757 memcpy(pKey->abyKey, pbyKey, uKeyLength);
758 if (byKeyDecMode == KEY_CTL_WEP) {
759 if (uKeyLength == WLAN_WEP40_KEYLEN)
760 pKey->abyKey[15] &= 0x7F;
761 if (uKeyLength == WLAN_WEP104_KEYLEN)
762 pKey->abyKey[15] |= 0x80;
763 }
764 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pTable->KeyTable[i].abyBSSID, (u32 *)pKey->abyKey, byLocalID);
765
766 if ((dwKeyIndex & USE_KEYRSC) == 0) {
767 // RSC set by NIC
768 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
769 } else {
770 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
771 }
772 pKey->dwTSC47_16 = 0;
773 pKey->wTSC15_0 = 0;
774
775 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybSetKey(R): \n");
776 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->bKeyValid: %d\n ", pKey->bKeyValid);
777 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
778 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pKey->abyKey: ");
779 for (ii = 0; ii < pKey->uKeyLength; ii++)
780 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
781
782 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "\n");
783
784 } // (pTable->KeyTable[i].bInUse == true)
785 }
786 return true;
787 }
Linux with added FPC-III support