📄 request.c
字号:
psWlan->auth_params[IW_AUTH_CIPHER_PAIRWISE] = psWlan->auth_params[IW_AUTH_CIPHER_GROUP];
psWlan->sChangeNetwork.boEncryptStatusChanged = TRUE;
DBG_LEV2(("Save the encryption status %d.\n", *(PULONG)pvInformationBuffer));
break;
case OID_802_11_RELOAD_DEFAULTS:
if ( *(PULONG)pvInformationBuffer != Ndis802_11ReloadWEPKeys )
iStatus = NDIS_STATUS_INVALID_DATA;
else
{
OS_MEMZERO( &psWlan->sWEPKeys, sizeof(MIB_WEP_DEF_KEYS) );
psWlan->ulDefaultWEPKeyId = 0;
psWlan->boTransmitKeyAvail = FALSE;
uValue.u32Uint32 = psWlan->ulDefaultWEPKeyId;
// Send Set MIB request (MIB_WEP_DEFAULT_KEYID) to Target.
vHALsendSetMibReq( psHAL, MIB_WEP_DEFAULT_KEYID, &uValue );
OS_MEMCPY( &uValue.sDefaultWEPKeys, &psWlan->sWEPKeys, sizeof(MIB_WEP_DEF_KEYS) );
// Send Set MIB request (MIB_WEP_DEFAULT_KEYS) to Target.
vHALsendSetMibReq( psHAL, MIB_WEP_DEFAULT_KEYS, &uValue );
DBG_LEV1(("Reload default Ndis802_11ReloadWEPKeys - zeroes.\n"));
}
break;
case OID_802_11_ADD_KEY:
{
PNDIS_802_11_KEY psKey = (PNDIS_802_11_KEY) pvInformationBuffer;
UMI_SET_KEY sSetKey;
ULONG ulLength;
// Check the buffer length.
ulLength = FIELD_OFFSET(NDIS_802_11_KEY, KeyMaterial) + psKey->KeyLength;
if ( psKey->Length < ulLength )
{
*pulBytesNeeded = ulLength;
iStatus = NDIS_STATUS_INVALID_LENGTH;
}
else if ( (psKey->KeyIndex & 0xC0000000) == 0x40000000 || // Pairwise key, but not transmit key.
(psKey->KeyIndex & 0x10000000) || // 802.1X authenticator.
(psKey->KeyIndex & 0x400000FF) > 0x40000000 || // Pairwise key, but index not zero.
(psKey->KeyIndex & 0x0FFFFF00) ) // Other bits set.
iStatus = NDIS_STATUS_INVALID_DATA;
else if (psWlan->auth_params[IW_AUTH_WPA_VERSION] &
(IW_AUTH_WPA_VERSION_WPA2 | IW_AUTH_WPA_VERSION_WPA))
{
// Bit 31, transmit key flag.
if ( psKey->KeyIndex & 0x80000000 )
{
// Pairwise key or group transmit key.
if ( psKey->KeyIndex & 0x40000000 )
psWlan->ulGroupTransmitKey = 0;
else if ( psWlan->ulGroupTransmitKey || !psWlan->boTransmitKeyAvail )
psWlan->ulGroupTransmitKey = (psKey->KeyIndex & 0x000000FF) + 1;
psWlan->boTransmitKeyAvail = TRUE;
// Key installed, turn off the non-802.1X EAPOL packet filter.
psWlan->boNonEAPOLPktFilter = FALSE;
}
OS_MEMZERO( &sSetKey, sizeof( UMI_SET_KEY ) );
// Bit 30, pairwise key flag.
sSetKey.u16KeyType = (psKey->KeyIndex & 0x40000000) ?
UMI_RSN_PAIRWISE_KEY : UMI_RSN_GROUP_KEY;
OS_MEMCPY( &sSetKey.sStationID, psKey->BSSID, IEEE_ADDR_LEN );
sSetKey.u16StationRole = UMI_RSN_SUPPLICANT;
switch ( psKey->KeyLength )
{
case MIB_WEP_KEY_WEP1_LENGTH:
sSetKey.u16CipherSuite = UMI_RSN_CIPHER_SUITE_WEP40;
break;
case MIB_WEP_KEY_MAX_LENGTH:
sSetKey.u16CipherSuite = UMI_RSN_CIPHER_SUITE_WEP104;
break;
case 16: // 128-bit, AES key.
sSetKey.u16CipherSuite = UMI_RSN_CIPHER_SUITE_CCMP;
break;
case 32: // 256-bit, TKIP key.
sSetKey.u16CipherSuite = UMI_RSN_CIPHER_SUITE_TKIP;
break;
default:
sSetKey.u16CipherSuite = UMI_RSN_CIPHER_SUITE_NONE;
psKey->KeyLength = 0;
break;
}
sSetKey.u16DefaultKeyIndex = (USHORT)(psKey->KeyIndex & 0x000000FF);
// Bit 29, init RSC flag.
if ( psKey->KeyIndex & 0x20000000 )
OS_MEMCPY( sSetKey.au8RxSeqNum, &psKey->KeyRSC, UMI_RSN_SEQ_NUM_LEN );
sSetKey.au8TxSeqNum[0] = 1;
OS_MEMCPY( sSetKey.au8Tk1, psKey->KeyMaterial, psKey->KeyLength );
*pulBytesRead = ulLength;
// Send SetKey request to Target.
vHALsendSetKeyReq( psHAL, &sSetKey );
}
else
{
// This is a WEP key for regular WEP (non-WPA,
// non-RSN). This case looks almost exactly like
// OID_802_11_ADD_WEP.
ULONG ulIndex;
DBG_LEV1(("Treating Add Key like Add Wep\n"));
// Make sure key length corresponds to WEP
if ( (psKey->KeyLength != MIB_WEP_KEY_WEP1_LENGTH) && (psKey->KeyLength != MIB_WEP_KEY_MAX_LENGTH) )
{
iStatus = NDIS_STATUS_INVALID_DATA;
DBG_LEV1(("Bad WEP KeyLength: %d\n", psKey->KeyLength));
break;
}
ulIndex = psKey->KeyIndex & 0x03;
if (psKey->KeyIndex & 0x80000000)
{
psWlan->boTransmitKeyAvail = TRUE;
psWlan->ulDefaultWEPKeyId = ulIndex;
uValue.u32Uint32 = psWlan->ulDefaultWEPKeyId;
vHALsendSetMibReq( psHAL,
MIB_WEP_DEFAULT_KEYID,
&uValue );
}
// Backup the WEP key.
psWlan->sWEPKeys.sKey[ulIndex].u8KeyLength =
(UCHAR)psKey->KeyLength;
OS_MEMZERO(
psWlan->sWEPKeys.sKey[ulIndex].au8KeyData,
MIB_WEP_KEY_MAX_LENGTH );
OS_MEMCPY(
psWlan->sWEPKeys.sKey[ulIndex].au8KeyData,
psKey->KeyMaterial, psKey->KeyLength );
*pulBytesRead = ulLength;
OS_MEMCPY( &uValue.sDefaultWEPKeys,
&psWlan->sWEPKeys,
sizeof(MIB_WEP_DEF_KEYS) );
vHALsendSetMibReq( psHAL, MIB_WEP_DEFAULT_KEYS,
&uValue );
}
DBG_LEV1(("Add Key, key index 0x%x, key length %d, status = 0x%x\n",
psKey->KeyIndex, psKey->KeyLength, iStatus));
}
break;
case OID_802_11_REMOVE_KEY:
{
PNDIS_802_11_REMOVE_KEY psRemoveKey = (PNDIS_802_11_REMOVE_KEY) pvInformationBuffer;
UMI_CLEAR_KEY sClearKey;
if ( psRemoveKey->KeyIndex & 0x8FFFFF00 )
iStatus = NDIS_STATUS_INVALID_DATA;
else
{
// Check whether transmit key removed.
if ( psRemoveKey->KeyIndex & 0x40000000 )
psWlan->boTransmitKeyAvail = FALSE;
else if ( (psRemoveKey->KeyIndex & 0x000000FF) + 1 == psWlan->ulGroupTransmitKey )
{
psWlan->ulGroupTransmitKey = 0;
psWlan->boTransmitKeyAvail = FALSE;
}
if (psWlan->auth_params[IW_AUTH_WPA_VERSION] & IW_AUTH_WPA_VERSION_DISABLED)
{
ULONG ulIndex;
ulIndex = psRemoveKey->KeyIndex & 0x03;
if (ulIndex == psWlan->ulDefaultWEPKeyId)
{
psWlan->boTransmitKeyAvail = FALSE;
}
// Clear out the WEP key.
OS_MEMZERO(
psWlan->sWEPKeys.sKey[ulIndex].au8KeyData,
MIB_WEP_KEY_MAX_LENGTH );
psWlan->sWEPKeys.sKey[ulIndex].u8KeyLength = 0;
OS_MEMCPY( &uValue.sDefaultWEPKeys,
&psWlan->sWEPKeys,
sizeof(MIB_WEP_DEF_KEYS) );
vHALsendSetMibReq( psHAL,
MIB_WEP_DEFAULT_KEYS,
&uValue );
DBG_LEV1(("Clear WEP, key index 0x%x.\n", ulIndex));
}
else
{
OS_MEMZERO( &sClearKey, sizeof( UMI_CLEAR_KEY ) );
// Bit 30, pairwise key flag.
sClearKey.u16KeyType = (psRemoveKey->KeyIndex & 0x40000000) ?
UMI_RSN_PAIRWISE_KEY : UMI_RSN_GROUP_KEY;
OS_MEMCPY( &sClearKey.sStationID, psRemoveKey->BSSID, IEEE_ADDR_LEN );
// Send ClearKey request to Target.
vHALsendClearKeyReq( psHAL, &sClearKey );
}
*pulBytesRead = sizeof(NDIS_802_11_REMOVE_KEY);
DBG_LEV3(("Remove Key, key index 0x%x.\n", psRemoveKey->KeyIndex));
}
}
break;
case OID_802_11_ASSOCIATION_INFORMATION:
*pulBytesRead = ulInformationBufferLength;
break;
case OID_802_11_TEST:
{
PNDIS_802_11_TEST psTest = (PNDIS_802_11_TEST)pvInformationBuffer;
PVOID pvStatusBuf;
ULONG ulStatusBufSize;
if ( psTest->Type != 1 && psTest->Type != 2 )
iStatus = NDIS_STATUS_INVALID_DATA;
else
{
if ( psTest->Type == 1 ) // Authentication indication test.
{
pvStatusBuf = (PVOID)&psTest->AuthenticationEvent.Status;
ulStatusBufSize = psTest->Length - 8;
}
else // RSSI indication test.
{
pvStatusBuf = (PVOID)&psTest->RssiTrigger;
ulStatusBufSize = sizeof( NDIS_802_11_RSSI );
}
NdisMIndicateStatus(
psAdapter->hMiniportAdapterHandle,
NDIS_STATUS_MEDIA_SPECIFIC_INDICATION,
pvStatusBuf,
ulStatusBufSize);
NdisMIndicateStatusComplete( psAdapter->hMiniportAdapterHandle );
}
}
break;
case OID_802_11_MEDIA_STREAM_MODE:
if ( psAdapter->eNetState != NET_CONNECTED )
{
DBG_LEV1(("Rejected Set of OID_802_11_MEDIA_STREAM_MODE - STA not connected.\n"));
iStatus = NDIS_STATUS_ADAPTER_NOT_READY;
}
else
{
// Note: Setting the MIB_MEDIA_STREAM_MODE attribute to TRUE will
// abort any active background scans on the device but will
// allow any active host requested scans (i.e., set of
// OID_802_11_BSSID_LIST_SCAN) to finish as normal.
//
// Background scans on the device are prohibited whenever
// the MIB_MEDIA_STREAM_MODE attribute is TRUE
//
psWlan->ulMediaStreamModeInUse = *(PULONG)pvInformationBuffer;
uValue.u8Uint8 = (UCHAR)psWlan->ulMediaStreamModeInUse;
// Send Set MIB request (MIB_MEDIA_STREAM_MODE) to Target.
vHALsendSetMibReq( psHAL, MIB_MEDIA_STREAM_MODE, &uValue );
}
break;
//
// Dot11 OIDs.
//
case OID_DOT11_CURRENT_REG_DOMAIN:
if ( psWlan->ulRegDomain != *(PULONG)pvInformationBuffer )
{
ULONG ulIbssChannel = psWlan->ulIbssChannel;
psWlan->ulRegDomain = *(PULONG)pvInformationBuffer;
// Check domain and channel settings.
vENDcheckDomainChannel( psWlan->ulNetworkTypeInUse, &psWlan->ulRegDomain,
&psWlan->ulRestrChannel, &psWlan->ulIbssChannel );
if ( ulIbssChannel != psWlan->ulIbssChannel )
{
psWlan->sChangeNetwork.boIbssChannelChanged = TRUE;
}
if ( psAdapter->eNetState != NET_DISCONNECTED )
{
psWlan->boSetRegDomain = TRUE;
// Send Disconnect request first.
vHALsendDisconnectReq( psHAL, FRAME_REASON_DEAUTH_SENDER_LEAVING );
}
else
{
uValue.u8Uint8 = (uint8)psWlan->ulRegDomain;
// Send Set MIB request (MIB_CURRENT_REG_DOMAIN) to Target.
vHALsendSetMibReq( psHAL, MIB_CURRENT_REG_DOMAIN, &uValue );
}
}
break;
//
// Custom OIDs.
//
case OID_COMMASIC_TX_THRUPUT_PS_THRESHOLD:
psWlan->ulTxThruputPSThreshold = *(PULONG)pvInformationBuffer;
break;
case OID_COMMASIC_RX_THRUPUT_PS_THRESHOLD:
psWlan->ulRxThruputPSThreshold = *(PULONG)pvInformationBuffer;
break;
case OID_COMMASIC_SHORT_PREAMBLE:
psWlan->boShortPreamble = *(BOOLEAN *)pvInformationBuffer;
uValue.u8Uint8 = psWlan->boShortPreamble;
// Send Set MIB request (MIB_SHORT_PREAMBLE_OPTION_IMPLEMENTED) to Target.
vHALsendSetMibReq( psHAL, MIB_SHORT_PREAMBLE_OPTION_IMPLEMENTED, &uValue );
break;
case OID_COMMASIC_RX_BUF_OVERFLOW_CT:
if ( *(PULONG)pvInformationBuffer > 0 )
iStatus = NDIS_STATUS_INVALID_DATA;
else
{
psWlan->ulRxOverflows = 0;
uValue.u32Uint32 = 0;
// Send Set MIB request (MIB_RX_BUF_OVERFLOW_COUNT) to Target.
vHALsendSetMibReq( psHAL, MIB_RX_BUF_OVERFLOW_COUNT, &uValue );
}
break;
case OID_COMMASIC_RESET:
psAdapter->boNeedReset = TRUE;
break;
case OID_COMMASIC_UWA_SENS_LOCKOUT:
psWlan->boUwaSensLockout = *(BOOLEAN *)pvInformationBuffer;
uValue.u8Uint8 = psWlan->boUwaSensLockout;
// Send Set MIB request (MIB_UWA_SENS_LOCKOUT) to Target.
vHALsendSetMibReq( psHAL, MIB_UWA_SENS_LOCKOUT, &uValue );
break;
case OID_COMMASIC_RX_STATS:
// send clear stats to target
vHALsendClearUwaStatsReq( psHAL );
break;
case OID_COMMASIC_CONFIG:
psConfig = (PNDIS_COMMASIC_CONFIG)pvInformationBuffer;
//set each of the parameters that has its bit set in the parameter mask
// listen interval
if (psConfig->ParamMask & 0x1)
{
psWlan->ulListenInterval = psConfig->ListenInterval;
uValue.u16Uint16 = (uint16)psWlan->ulListenInterval;
// Send Set MIB request (MIB_LISTEN_INTERVAL) to Target.
vHALsendSetMibReq( psHAL, MIB_LISTEN_INTERVAL, &uValue );
}
// restricted channel
if (psConfig->ParamMask & 0x4)
{
psWlan->ulRestrChannel = psConfig->Channel;
uValue.u16Uint16 = (uint16)psWlan->ulRestrChannel;
// Send Set MIB request (MIB_RESTRICTED_CHANNEL_NUMBER) to Target.
vHALsendSetMibReq( psHAL, MIB_RESTRICTED_CHANNEL_NUMBER, &uValue );
}
// regulatory domain
if (psConfig->ParamMask & 0x8)
{
psWlan->ulRegDomain = psConfig->RegDomain;
uValue.u8Uint8 = (uint8)psWlan->ulRegDomain;
// Send Set MIB request (MIB_CURRENT_REG_DOMAIN) to Target.
vHALsendSetMibReq( psHAL, MIB_CURRENT_REG_DOMAIN, &uValue );
}
// MAC address
if (psConfig->ParamMask & 0x10)
{
psWlan->ucMacAddr[0] = psConfig->MacAddr[0];
psWlan->ucMacAddr[1] = psConfig->MacAddr[1];
psWlan->ucMacAddr[2] = psConfig->MacAddr[2];
psWlan->ucMacAddr[3] = psConfig->MacAddr[3];
psWlan->ucMacAddr[4] = psConfig->MacAddr[4];
psWlan->ucMacAddr[5] = psConfig->MacAddr[5];
uValue.au8ListOfu8.au8Elements[0] = psWlan->ucMacAddr[0];
uValue.au8ListOfu8.au8Elements[1] = psWlan->ucMacAddr[1];
uValue.au8ListOfu8.au8Elements[2] = psWlan->ucMacAddr[2];
uValue.au8ListOfu8.au8Elements[3] = psWlan->ucMacAddr[3];
uValue.au8ListOfu8.au8Elements[4] = psWlan->ucMacAddr[4];
uValue.au8ListOfu8.au8Elements[5] = psWlan->ucMacAddr[5];
vHALsendSetMibReq( psHAL, MIB_IEEE_ADDRESS, &uValue );
}
// reset device after setting custom config params
psAdapter->boNeedReset = TRUE;
break;
case OID_COMMASIC_GEN_STATS:
// send clear stats to target
vHALsendClearGenS⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -