projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge commit '3ff195b011d7decf501a4d55aeed312731094796' into for-linus
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6656 / key.c
CommitLineData
92b96797
FB		 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
92b96797 39#include "tmacro.h"
92b96797 40#include "key.h"
92b96797 41#include "mac.h"
92b96797 42#include "rndis.h"
92b96797 43#include "control.h"
92b96797
FB		 44
45/*--------------------- Static Definitions -------------------------*/
46
47/*--------------------- Static Classes ----------------------------*/
48
49/*--------------------- Static Variables --------------------------*/
50static int msglevel =MSG_LEVEL_INFO;
51//static int msglevel =MSG_LEVEL_DEBUG;
52/*--------------------- Static Functions --------------------------*/
53
54/*--------------------- Export Variables --------------------------*/
55
56/*--------------------- Static Definitions -------------------------*/
57
58/*--------------------- Static Classes ----------------------------*/
59
60/*--------------------- Static Variables --------------------------*/
61
62/*--------------------- Static Functions --------------------------*/
63static VOID
64s_vCheckKeyTableValid (PVOID pDeviceHandler, PSKeyManagement pTable)
65{
66 PSDevice pDevice = (PSDevice) pDeviceHandler;
67 int i;
68 WORD wLength = 0;
69 BYTE pbyData[MAX_KEY_TABLE];
70
71 for (i=0;i<MAX_KEY_TABLE;i++) {
72 if ((pTable->KeyTable[i].bInUse == TRUE) &&
73 (pTable->KeyTable[i].PairwiseKey.bKeyValid == FALSE) &&
74 (pTable->KeyTable[i].GroupKey[0].bKeyValid == FALSE) &&
75 (pTable->KeyTable[i].GroupKey[1].bKeyValid == FALSE) &&
76 (pTable->KeyTable[i].GroupKey[2].bKeyValid == FALSE) &&
77 (pTable->KeyTable[i].GroupKey[3].bKeyValid == FALSE)
78 ) {
79
80 pTable->KeyTable[i].bInUse = FALSE;
81 pTable->KeyTable[i].wKeyCtl = 0;
82 pTable->KeyTable[i].bSoftWEP = FALSE;
83 pbyData[wLength++] = (BYTE) i;
84 //MACvDisableKeyEntry(pDevice, i);
85 }
86 }
87 if ( wLength != 0 ) {
88 CONTROLnsRequestOut(pDevice,
89 MESSAGE_TYPE_CLRKEYENTRY,
90 0,
91 0,
92 wLength,
93 pbyData
94 );
95 }
96
97}
98
99
100/*--------------------- Export Functions --------------------------*/
101
102
103/*
104 * Description: Init Key management table
105 *
106 * Parameters:
107 * In:
108 * pTable - Pointer to Key table
109 * Out:
110 * none
111 *
112 * Return Value: none
113 *
114 */
115VOID KeyvInitTable(PVOID pDeviceHandler, PSKeyManagement pTable)
116{
117 PSDevice pDevice = (PSDevice) pDeviceHandler;
118 int i;
119 int jj;
120 BYTE pbyData[MAX_KEY_TABLE+1];
121
122 spin_lock_irq(&pDevice->lock);
123 for (i=0;i<MAX_KEY_TABLE;i++) {
124 pTable->KeyTable[i].bInUse = FALSE;
125 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
126 pTable->KeyTable[i].PairwiseKey.pvKeyTable = (PVOID)&pTable->KeyTable[i];
127 for (jj=0; jj < MAX_GROUP_KEY; jj++) {
128 pTable->KeyTable[i].GroupKey[jj].bKeyValid = FALSE;
129 pTable->KeyTable[i].GroupKey[jj].pvKeyTable = (PVOID) &(pTable->KeyTable[i]);
130 }
131 pTable->KeyTable[i].wKeyCtl = 0;
132 pTable->KeyTable[i].dwGTKeyIndex = 0;
133 pTable->KeyTable[i].bSoftWEP = FALSE;
134 pbyData[i] = (BYTE) i;
135 }
136 pbyData[i] = (BYTE) i;
137 CONTROLnsRequestOut(pDevice,
138 MESSAGE_TYPE_CLRKEYENTRY,
139 0,
140 0,
141 11,
142 pbyData
143 );
144
145 spin_unlock_irq(&pDevice->lock);
146
147 return;
148}
149
150
151/*
152 * Description: Get Key from table
153 *
154 * Parameters:
155 * In:
156 * pTable - Pointer to Key table
157 * pbyBSSID - BSSID of Key
158 * dwKeyIndex - Key Index (0xFFFFFFFF means pairwise key)
159 * Out:
160 * pKey - Key return
161 *
162 * Return Value: TRUE if found otherwise FALSE
163 *
164 */
165BOOL KeybGetKey (
166 IN PSKeyManagement pTable,
167 IN PBYTE pbyBSSID,
168 IN DWORD dwKeyIndex,
169 OUT PSKeyItem *pKey
170 )
171{
172 int i;
173
174 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybGetKey() \n");
175
176 *pKey = NULL;
177 for (i=0;i<MAX_KEY_TABLE;i++) {
178 if ((pTable->KeyTable[i].bInUse == TRUE) &&
179 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
180 if (dwKeyIndex == 0xFFFFFFFF) {
181 if (pTable->KeyTable[i].PairwiseKey.bKeyValid == TRUE) {
182 *pKey = &(pTable->KeyTable[i].PairwiseKey);
183 return (TRUE);
184 }
185 else {
186 return (FALSE);
187 }
188 } else if (dwKeyIndex < MAX_GROUP_KEY) {
189 if (pTable->KeyTable[i].GroupKey[dwKeyIndex].bKeyValid == TRUE) {
190 *pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex]);
191 return (TRUE);
192 }
193 else {
194 return (FALSE);
195 }
196 }
197 else {
198 return (FALSE);
199 }
200 }
201 }
202 return (FALSE);
203}
204
205
206/*
207 * Description: Set Key to table
208 *
209 * Parameters:
210 * In:
211 * pTable - Pointer to Key table
212 * pbyBSSID - BSSID of Key
213 * dwKeyIndex - Key index (reference to NDIS DDK)
214 * uKeyLength - Key length
215 * KeyRSC - Key RSC
216 * pbyKey - Pointer to key
217 * Out:
218 * none
219 *
220 * Return Value: TRUE if success otherwise FALSE
221 *
222 */
223BOOL KeybSetKey (
224 PVOID pDeviceHandler,
225 PSKeyManagement pTable,
226 PBYTE pbyBSSID,
227 DWORD dwKeyIndex,
228 ULONG uKeyLength,
229 PQWORD pKeyRSC,
230 PBYTE pbyKey,
231 BYTE byKeyDecMode
232 )
233{
234 PSDevice pDevice = (PSDevice) pDeviceHandler;
235 int i,j;
236 UINT ii;
237 PSKeyItem pKey;
238 UINT uKeyIdx;
239
240 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Enter KeybSetKey: %lX\n", dwKeyIndex);
241
242 j = (MAX_KEY_TABLE-1);
243 for (i=0;i<(MAX_KEY_TABLE-1);i++) {
244 if ((pTable->KeyTable[i].bInUse == FALSE) &&
245 (j == (MAX_KEY_TABLE-1))) {
246 // found empty table
247 j = i;
248 }
249 if ((pTable->KeyTable[i].bInUse == TRUE) &&
250 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
251 // found table already exist
252 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
253 // Pairwise key
254 pKey = &(pTable->KeyTable[i].PairwiseKey);
255 pTable->KeyTable[i].wKeyCtl &= 0xFFF0; // clear pairwise key control filed
256 pTable->KeyTable[i].wKeyCtl |= byKeyDecMode;
257 uKeyIdx = 4; // use HW key entry 4 for pairwise key
258 } else {
259 // Group key
260 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
261 return (FALSE);
262 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
263 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
264 // Group transmit key
265 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
266 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[i].dwGTKeyIndex, i);
267 }
268 pTable->KeyTable[i].wKeyCtl &= 0xFF0F; // clear group key control filed
269 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
270 pTable->KeyTable[i].wKeyCtl |= 0x0040; // use group key for group address
271 uKeyIdx = (dwKeyIndex & 0x000000FF);
272 }
273 pTable->KeyTable[i].wKeyCtl |= 0x8000; // enable on-fly
274
275 pKey->bKeyValid = TRUE;
276 pKey->uKeyLength = uKeyLength;
277 pKey->dwKeyIndex = dwKeyIndex;
278 pKey->byCipherSuite = byKeyDecMode;
3e362598 279 memcpy(pKey->abyKey, pbyKey, uKeyLength);
92b96797
FB		 280 if (byKeyDecMode == KEY_CTL_WEP) {
281 if (uKeyLength == WLAN_WEP40_KEYLEN)
282 pKey->abyKey[15] &= 0x7F;
283 if (uKeyLength == WLAN_WEP104_KEYLEN)
284 pKey->abyKey[15] |= 0x80;
285 }
286 MACvSetKeyEntry(pDevice, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pbyBSSID, (PDWORD)pKey->abyKey);
287
288 if ((dwKeyIndex & USE_KEYRSC) == 0) {
289 // RSC set by NIC
3e362598 290 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
92b96797
FB		 291 }
292 else {
3e362598 293 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
92b96797
FB		 294 }
295 pKey->dwTSC47_16 = 0;
296 pKey->wTSC15_0 = 0;
297
298 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(R): \n");
299 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n ", pKey->bKeyValid);
300 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n ", pKey->uKeyLength);
301 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: ");
302 for (ii = 0; ii < pKey->uKeyLength; ii++) {
303 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
304 }
305 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
306
307 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
308 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
309 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
310
311 return (TRUE);
312 }
313 }
314 if (j < (MAX_KEY_TABLE-1)) {
3e362598 315 memcpy(pTable->KeyTable[j].abyBSSID,pbyBSSID,U_ETHER_ADDR_LEN);
92b96797
FB		 316 pTable->KeyTable[j].bInUse = TRUE;
317 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
318 // Pairwise key
319 pKey = &(pTable->KeyTable[j].PairwiseKey);
320 pTable->KeyTable[j].wKeyCtl &= 0xFFF0; // clear pairwise key control filed
321 pTable->KeyTable[j].wKeyCtl |= byKeyDecMode;
322 uKeyIdx = 4; // use HW key entry 4 for pairwise key
323 } else {
324 // Group key
325 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
326 return (FALSE);
327 pKey = &(pTable->KeyTable[j].GroupKey[dwKeyIndex & 0x000000FF]);
328 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
329 // Group transmit key
330 pTable->KeyTable[j].dwGTKeyIndex = dwKeyIndex;
331 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(N)[%lX]: %d\n", pTable->KeyTable[j].dwGTKeyIndex, j);
332 }
333 pTable->KeyTable[j].wKeyCtl &= 0xFF0F; // clear group key control filed
334 pTable->KeyTable[j].wKeyCtl |= (byKeyDecMode << 4);
335 pTable->KeyTable[j].wKeyCtl |= 0x0040; // use group key for group address
336 uKeyIdx = (dwKeyIndex & 0x000000FF);
337 }
338 pTable->KeyTable[j].wKeyCtl |= 0x8000; // enable on-fly
339
340 pKey->bKeyValid = TRUE;
341 pKey->uKeyLength = uKeyLength;
342 pKey->dwKeyIndex = dwKeyIndex;
343 pKey->byCipherSuite = byKeyDecMode;
3e362598 344 memcpy(pKey->abyKey, pbyKey, uKeyLength);
92b96797
FB		 345 if (byKeyDecMode == KEY_CTL_WEP) {
346 if (uKeyLength == WLAN_WEP40_KEYLEN)
347 pKey->abyKey[15] &= 0x7F;
348 if (uKeyLength == WLAN_WEP104_KEYLEN)
349 pKey->abyKey[15] |= 0x80;
350 }
351 MACvSetKeyEntry(pDevice, pTable->KeyTable[j].wKeyCtl, j, uKeyIdx, pbyBSSID, (PDWORD)pKey->abyKey);
352
353 if ((dwKeyIndex & USE_KEYRSC) == 0) {
354 // RSC set by NIC
3e362598 355 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
92b96797
FB		 356 }
357 else {
3e362598 358 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
92b96797
FB		 359 }
360 pKey->dwTSC47_16 = 0;
361 pKey->wTSC15_0 = 0;
362
363 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(N): \n");
364 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n ", pKey->bKeyValid);
365 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
366 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: ");
367 for (ii = 0; ii < pKey->uKeyLength; ii++) {
368 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
369 }
370 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
371
372 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
373 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
374 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
375
376 return (TRUE);
377 }
378 return (FALSE);
379}
380
381
382/*
383 * Description: Remove Key from table
384 *
385 * Parameters:
386 * In:
387 * pTable - Pointer to Key table
388 * pbyBSSID - BSSID of Key
389 * dwKeyIndex - Key Index (reference to NDIS DDK)
390 * Out:
391 * none
392 *
393 * Return Value: TRUE if success otherwise FALSE
394 *
395 */
396BOOL KeybRemoveKey (
397 PVOID pDeviceHandler,
398 PSKeyManagement pTable,
399 PBYTE pbyBSSID,
400 DWORD dwKeyIndex
401 )
402{
403 PSDevice pDevice = (PSDevice) pDeviceHandler;
404 int i;
405 BOOL bReturnValue = FALSE;
406
407 if (IS_BROADCAST_ADDRESS(pbyBSSID)) {
408 // dealte all key
409 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
410 for (i=0;i<MAX_KEY_TABLE;i++) {
411 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
412 }
413 bReturnValue = TRUE;
414 }
415 else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
416 for (i=0;i<MAX_KEY_TABLE;i++) {
417 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = FALSE;
418 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
419 // remove Group transmit key
420 pTable->KeyTable[i].dwGTKeyIndex = 0;
421 }
422 }
423 bReturnValue = TRUE;
424 }
425 else {
426 bReturnValue = FALSE;
427 }
428
429 } else {
430 for (i=0;i<MAX_KEY_TABLE;i++) {
431 if ( (pTable->KeyTable[i].bInUse == TRUE) &&
432 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
433
434 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
435 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
436 bReturnValue = TRUE;
437 break;
438 }
439 else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
440 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = FALSE;
441 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
442 // remove Group transmit key
443 pTable->KeyTable[i].dwGTKeyIndex = 0;
444 }
445 bReturnValue = TRUE;
446 break;
447 }
448 else {
449 bReturnValue = FALSE;
450 break;
451 }
452 } //pTable->KeyTable[i].bInUse == TRUE
453 } //for
454 bReturnValue = TRUE;
455 }
456
457 s_vCheckKeyTableValid(pDevice,pTable);
458 return bReturnValue;
459
460
461}
462
463
464/*
465 * Description: Remove Key from table
466 *
467 * Parameters:
468 * In:
469 * pTable - Pointer to Key table
470 * pbyBSSID - BSSID of Key
471 * Out:
472 * none
473 *
474 * Return Value: TRUE if success otherwise FALSE
475 *
476 */
477BOOL KeybRemoveAllKey (
478 PVOID pDeviceHandler,
479 PSKeyManagement pTable,
480 PBYTE pbyBSSID
481 )
482{
483 PSDevice pDevice = (PSDevice) pDeviceHandler;
484 int i,u;
485
486 for (i=0;i<MAX_KEY_TABLE;i++) {
487 if ((pTable->KeyTable[i].bInUse == TRUE) &&
488 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
489 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
490 for(u=0;u<MAX_GROUP_KEY;u++) {
491 pTable->KeyTable[i].GroupKey[u].bKeyValid = FALSE;
492 }
493 pTable->KeyTable[i].dwGTKeyIndex = 0;
494 s_vCheckKeyTableValid(pDevice, pTable);
495 return (TRUE);
496 }
497 }
498 return (FALSE);
499}
500
501/*
502 * Description: Remove WEP Key from table
503 *
504 * Parameters:
505 * In:
506 * pTable - Pointer to Key table
507 * Out:
508 * none
509 *
510 * Return Value: TRUE if success otherwise FALSE
511 *
512 */
513VOID KeyvRemoveWEPKey (
514 PVOID pDeviceHandler,
515 PSKeyManagement pTable,
516 DWORD dwKeyIndex
517 )
518{
519 PSDevice pDevice = (PSDevice) pDeviceHandler;
520
521 if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
522 if (pTable->KeyTable[MAX_KEY_TABLE-1].bInUse == TRUE) {
523 if (pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].byCipherSuite == KEY_CTL_WEP) {
524 pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = FALSE;
525 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex & 0x7FFFFFFF)) {
526 // remove Group transmit key
527 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = 0;
528 }
529 }
530 }
531 s_vCheckKeyTableValid(pDevice, pTable);
532 }
533 return;
534}
535
536VOID KeyvRemoveAllWEPKey (
537 PVOID pDeviceHandler,
538 PSKeyManagement pTable
539 )
540{
541 PSDevice pDevice = (PSDevice) pDeviceHandler;
542
543 int i;
544
545 for(i=0;i<MAX_GROUP_KEY;i++) {
546 KeyvRemoveWEPKey(pDevice,pTable, i);
547 }
548
549}
550
551/*
552 * Description: Get Transmit Key from table
553 *
554 * Parameters:
555 * In:
556 * pTable - Pointer to Key table
557 * pbyBSSID - BSSID of Key
558 * Out:
559 * pKey - Key return
560 *
561 * Return Value: TRUE if found otherwise FALSE
562 *
563 */
564BOOL KeybGetTransmitKey (
565 IN PSKeyManagement pTable,
566 IN PBYTE pbyBSSID,
567 IN DWORD dwKeyType,
568 OUT PSKeyItem *pKey
569 )
570{
571 int i, ii;
572
573 *pKey = NULL;
574 for (i=0;i<MAX_KEY_TABLE;i++) {
575 if ((pTable->KeyTable[i].bInUse == TRUE) &&
576 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
577
578 if (dwKeyType == PAIRWISE_KEY) {
579
580 if (pTable->KeyTable[i].PairwiseKey.bKeyValid == TRUE) {
581 *pKey = &(pTable->KeyTable[i].PairwiseKey);
582
583 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybGetTransmitKey:");
584 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"PAIRWISE_KEY: KeyTable.abyBSSID: ");
585 for (ii = 0; ii < 6; ii++) {
586 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%x ", pTable->KeyTable[i].abyBSSID[ii]);
587 }
588 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
589
590
591 return (TRUE);
592 }
593 else {
594 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"PairwiseKey.bKeyValid == FALSE\n");
595 return (FALSE);
596 }
597 } // End of Type == PAIRWISE
598 else {
599 if (pTable->KeyTable[i].dwGTKeyIndex == 0) {
600 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ERROR: dwGTKeyIndex == 0 !!!\n");
601 return FALSE;
602 }
603 if (pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)].bKeyValid == TRUE) {
604 *pKey = &(pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)]);
605
606 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybGetTransmitKey:");
607 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GROUP_KEY: KeyTable.abyBSSID\n");
608 for (ii = 0; ii < 6; ii++) {
609 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%x ", pTable->KeyTable[i].abyBSSID[ii]);
610 }
611 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
612 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"dwGTKeyIndex: %lX\n", pTable->KeyTable[i].dwGTKeyIndex);
613
614 return (TRUE);
615 }
616 else {
617 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GroupKey.bKeyValid == FALSE\n");
618 return (FALSE);
619 }
620 } // End of Type = GROUP
621 } // BSSID match
622 }
623 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ERROR: NO Match BSSID !!! ");
624 for (ii = 0; ii < 6; ii++) {
625 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *(pbyBSSID+ii));
626 }
627 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
628 return (FALSE);
629}
630
631
632/*
633 * Description: Check Pairewise Key
634 *
635 * Parameters:
636 * In:
637 * pTable - Pointer to Key table
638 * Out:
639 * none
640 *
641 * Return Value: TRUE if found otherwise FALSE
642 *
643 */
644BOOL KeybCheckPairewiseKey (
645 IN PSKeyManagement pTable,
646 OUT PSKeyItem *pKey
647 )
648{
649 int i;
650
651 *pKey = NULL;
652 for (i=0;i<MAX_KEY_TABLE;i++) {
653 if ((pTable->KeyTable[i].bInUse == TRUE) &&
654 (pTable->KeyTable[i].PairwiseKey.bKeyValid == TRUE)) {
655 *pKey = &(pTable->KeyTable[i].PairwiseKey);
656 return (TRUE);
657 }
658 }
659 return (FALSE);
660}
661
662/*
663 * Description: Set Key to table
664 *
665 * Parameters:
666 * In:
667 * pTable - Pointer to Key table
668 * dwKeyIndex - Key index (reference to NDIS DDK)
669 * uKeyLength - Key length
670 * KeyRSC - Key RSC
671 * pbyKey - Pointer to key
672 * Out:
673 * none
674 *
675 * Return Value: TRUE if success otherwise FALSE
676 *
677 */
678BOOL KeybSetDefaultKey (
679 PVOID pDeviceHandler,
680 PSKeyManagement pTable,
681 DWORD dwKeyIndex,
682 ULONG uKeyLength,
683 PQWORD pKeyRSC,
684 PBYTE pbyKey,
685 BYTE byKeyDecMode
686 )
687{
688 PSDevice pDevice = (PSDevice) pDeviceHandler;
689 UINT ii;
690 PSKeyItem pKey;
691 UINT uKeyIdx;
692
693 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Enter KeybSetDefaultKey: %1x, %d \n", (int)dwKeyIndex, (int)uKeyLength);
694
695
696 if ((dwKeyIndex & PAIRWISE_KEY) != 0) { // Pairwise key
697 return (FALSE);
698 } else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY) {
699 return (FALSE);
700 }
701
702 pTable->KeyTable[MAX_KEY_TABLE-1].bInUse = TRUE;
703 for(ii=0;ii<U_ETHER_ADDR_LEN;ii++)
704 pTable->KeyTable[MAX_KEY_TABLE-1].abyBSSID[ii] = 0xFF;
705
706 // Group key
707 pKey = &(pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF]);
708 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
709 // Group transmit key
710 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = dwKeyIndex;
711 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);
712
713 }
714 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl &= 0x7F00; // clear all key control filed
715 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode << 4);
716 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode);
717 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x0044; // use group key for all address
718 uKeyIdx = (dwKeyIndex & 0x000000FF);
719
720 if ((uKeyLength == WLAN_WEP232_KEYLEN) &&
721 (byKeyDecMode == KEY_CTL_WEP)) {
722 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x4000; // disable on-fly disable address match
723 pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP = TRUE;
724 } else {
725 if (pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP == FALSE)
726 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0xC000; // enable on-fly disable address match
727 }
728
729 pKey->bKeyValid = TRUE;
730 pKey->uKeyLength = uKeyLength;
731 pKey->dwKeyIndex = dwKeyIndex;
732 pKey->byCipherSuite = byKeyDecMode;
3e362598 733 memcpy(pKey->abyKey, pbyKey, uKeyLength);
92b96797
FB		 734 if (byKeyDecMode == KEY_CTL_WEP) {
735 if (uKeyLength == WLAN_WEP40_KEYLEN)
736 pKey->abyKey[15] &= 0x7F;
737 if (uKeyLength == WLAN_WEP104_KEYLEN)
738 pKey->abyKey[15] |= 0x80;
739 }
740
741 MACvSetKeyEntry(pDevice, pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl, MAX_KEY_TABLE-1, uKeyIdx, pTable->KeyTable[MAX_KEY_TABLE-1].abyBSSID, (PDWORD) pKey->abyKey);
742
743 if ((dwKeyIndex & USE_KEYRSC) == 0) {
744 // RSC set by NIC
3e362598 745 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
92b96797 746 } else {
3e362598 747 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
92b96797
FB		 748 }
749 pKey->dwTSC47_16 = 0;
750 pKey->wTSC15_0 = 0;
751
752
753 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(R): \n");
754 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n", pKey->bKeyValid);
755 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n", (int)pKey->uKeyLength);
756 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: \n");
757 for (ii = 0; ii < pKey->uKeyLength; ii++) {
758 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%x", pKey->abyKey[ii]);
759 }
760 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
761
762 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwTSC47_16: %lx\n", pKey->dwTSC47_16);
763 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->wTSC15_0: %x\n", pKey->wTSC15_0);
764 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwKeyIndex: %lx\n", pKey->dwKeyIndex);
765
766 return (TRUE);
767}
768
769
770/*
771 * Description: Set Key to table
772 *
773 * Parameters:
774 * In:
775 * pTable - Pointer to Key table
776 * dwKeyIndex - Key index (reference to NDIS DDK)
777 * uKeyLength - Key length
778 * KeyRSC - Key RSC
779 * pbyKey - Pointer to key
780 * Out:
781 * none
782 *
783 * Return Value: TRUE if success otherwise FALSE
784 *
785 */
786BOOL KeybSetAllGroupKey (
787 PVOID pDeviceHandler,
788 PSKeyManagement pTable,
789 DWORD dwKeyIndex,
790 ULONG uKeyLength,
791 PQWORD pKeyRSC,
792 PBYTE pbyKey,
793 BYTE byKeyDecMode
794 )
795{
796 PSDevice pDevice = (PSDevice) pDeviceHandler;
797 int i;
798 UINT ii;
799 PSKeyItem pKey;
800 UINT uKeyIdx;
801
802 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Enter KeybSetAllGroupKey: %lX\n", dwKeyIndex);
803
804
805 if ((dwKeyIndex & PAIRWISE_KEY) != 0) { // Pairwise key
806 return (FALSE);
807 } else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY) {
808 return (FALSE);
809 }
810
811 for (i=0; i < MAX_KEY_TABLE-1; i++) {
812 if (pTable->KeyTable[i].bInUse == TRUE) {
813 // found table already exist
814 // Group key
815 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
816 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
817 // Group transmit key
818 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
819 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[i].dwGTKeyIndex, i);
820
821 }
822 pTable->KeyTable[i].wKeyCtl &= 0xFF0F; // clear group key control filed
823 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
824 pTable->KeyTable[i].wKeyCtl |= 0x0040; // use group key for group address
825 uKeyIdx = (dwKeyIndex & 0x000000FF);
826
827 pTable->KeyTable[i].wKeyCtl |= 0x8000; // enable on-fly
828
829 pKey->bKeyValid = TRUE;
830 pKey->uKeyLength = uKeyLength;
831 pKey->dwKeyIndex = dwKeyIndex;
832 pKey->byCipherSuite = byKeyDecMode;
3e362598 833 memcpy(pKey->abyKey, pbyKey, uKeyLength);
92b96797
FB		 834 if (byKeyDecMode == KEY_CTL_WEP) {
835 if (uKeyLength == WLAN_WEP40_KEYLEN)
836 pKey->abyKey[15] &= 0x7F;
837 if (uKeyLength == WLAN_WEP104_KEYLEN)
838 pKey->abyKey[15] |= 0x80;
839 }
840
841 MACvSetKeyEntry(pDevice, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pTable->KeyTable[i].abyBSSID, (PDWORD) pKey->abyKey);
842
843 if ((dwKeyIndex & USE_KEYRSC) == 0) {
844 // RSC set by NIC
3e362598 845 memset(&(pKey->KeyRSC), 0, sizeof(QWORD));
92b96797
FB		 846 }
847 else {
3e362598 848 memcpy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
92b96797
FB		 849 }
850 pKey->dwTSC47_16 = 0;
851 pKey->wTSC15_0 = 0;
852
853 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(R): \n");
854 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n ", pKey->bKeyValid);
855 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
856 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: ");
857 for (ii = 0; ii < pKey->uKeyLength; ii++) {
858 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", pKey->abyKey[ii]);
859 }
860 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
861
862 //DBG_PRN_GRP12(("pKey->dwTSC47_16: %lX\n ", pKey->dwTSC47_16));
863 //DBG_PRN_GRP12(("pKey->wTSC15_0: %X\n ", pKey->wTSC15_0));
864 //DBG_PRN_GRP12(("pKey->dwKeyIndex: %lX\n ", pKey->dwKeyIndex));
865
866 } // (pTable->KeyTable[i].bInUse == TRUE)
867 }
868 return (TRUE);
869}
kernel source for telekom puls (alcatel/mediatek)