//005543f0 -> 100%
void CMasterLevelSystem::GDReqMasterLevelInfoSave(LPOBJ lpObj) //OK
{
if( !lpObj->m_bMasterLevelDBLoad )
{
return;
}
// ----
MLP_REQ_MASTERLEVEL_INFOSAVE pMsg;
pMsg.h.set((LPBYTE)&pMsg, 0x31, sizeof(MLP_REQ_MASTERLEVEL_INFOSAVE));
// ----
memcpy(pMsg.szCharName, lpObj->Name, MAX_IDSTRING);
pMsg.szCharName[MAX_IDSTRING] = 0;
pMsg.nMLevel = lpObj->m_nMasterLevel;
pMsg.i64MLExp = lpObj->m_i64MasterLevelExp;
pMsg.i64NextMLExp = lpObj->m_i64NextMasterLevelExp;
pMsg.nMLPoint = LOWORD(lpObj->m_iMasterLevelPoint);
// ----
cDBSMng.Send((char*)&pMsg, pMsg.h.size);
// ----
LogAddTD("[%s][%s] MasterLevel Info Save [MLevel:%d][MLExp:%I64d][MLNextExp:%I64d][MLPoint:%d]",
lpObj->AccountID, lpObj->Name, lpObj->m_nMasterLevel,
LODWORD(lpObj->m_i64MasterLevelExp), HIDWORD(lpObj->m_i64MasterLevelExp),
LODWORD(lpObj->m_i64NextMasterLevelExp), HIDWORD(lpObj->m_i64NextMasterLevelExp),
lpObj->m_iMasterLevelPoint);
}
BOOL ReadSectors( HANDLE hDevice, ULONGLONG ullStartSector, DWORD dwSectors, DWORD dwBytesPerSector, LPBYTE lpSectBuff, LPOVERLAPPED lpOverlap, DWORD *pdwErrorCode )
{
ULONGLONG ullOffset = ullStartSector * dwBytesPerSector;
DWORD dwLen = dwSectors * dwBytesPerSector;
DWORD dwReadLen = 0;
DWORD dwErrorCode = 0;
if (lpOverlap)
{
lpOverlap->Offset = LODWORD(ullOffset);
lpOverlap->OffsetHigh = HIDWORD(ullOffset);
}
else
{
LARGE_INTEGER liFileSize = {0};
liFileSize.QuadPart = (LONGLONG)ullOffset;
if (!SetFilePointerEx(hDevice,liFileSize,NULL,FILE_BEGIN))
{
*pdwErrorCode = GetLastError();
return FALSE;
}
}
if (!ReadFile(hDevice,lpSectBuff,dwLen,&dwReadLen,lpOverlap))
{
dwErrorCode = ::GetLastError();
if(dwErrorCode == ERROR_IO_PENDING) // 结束异步I/O
{
if (WaitForSingleObject(lpOverlap->hEvent, INFINITE) != WAIT_FAILED)
{
if(!::GetOverlappedResult(hDevice, lpOverlap, &dwReadLen, FALSE))
{
*pdwErrorCode = ::GetLastError();
return FALSE;
}
else
{
return TRUE;
}
}
else
{
*pdwErrorCode = ::GetLastError();
return FALSE;
}
}
else
{
*pdwErrorCode = dwErrorCode;
return FALSE;
}
}
else
{
return TRUE;
}
}
BOOL WriteFileAsyn( HANDLE hFile, ULONGLONG ullOffset, DWORD &dwSize, LPBYTE lpBuffer, LPOVERLAPPED lpOverlap, PDWORD pdwErrorCode )
{
DWORD dwWriteLen = 0;
DWORD dwErrorCode = 0;
if (lpOverlap)
{
lpOverlap->Offset = LODWORD(ullOffset);
lpOverlap->OffsetHigh = HIDWORD(ullOffset);
}
else
{
LARGE_INTEGER liFileSize = {0};
liFileSize.QuadPart = (LONGLONG)ullOffset;
if (!SetFilePointerEx(hFile,liFileSize,NULL,FILE_BEGIN))
{
*pdwErrorCode = GetLastError();
return FALSE;
}
}
if (!WriteFile(hFile,lpBuffer,dwSize,&dwWriteLen,lpOverlap))
{
dwErrorCode = ::GetLastError();
if(dwErrorCode == ERROR_IO_PENDING) // 结束异步I/O
{
if (WaitForSingleObject(lpOverlap->hEvent, INFINITE) != WAIT_FAILED)
{
if(!::GetOverlappedResult(hFile, lpOverlap, &dwWriteLen, FALSE))
{
*pdwErrorCode = ::GetLastError();
return FALSE;
}
else
{
dwSize = dwWriteLen;
return TRUE;
}
}
else
{
*pdwErrorCode = ::GetLastError();
return FALSE;
}
}
else
{
*pdwErrorCode = dwErrorCode;
return FALSE;
}
}
else
{
dwSize = dwWriteLen;
return TRUE;
}
}
// Completes a frame-step operation.
HRESULT EVRCustomPresenter::CompleteFrameStep(IMFSample *pSample)
{
HRESULT hr = S_OK;
MFTIME hnsSampleTime = 0;
MFTIME hnsSystemTime = 0;
// Update our state.
m_FrameStep.state = FRAMESTEP_COMPLETE;
m_FrameStep.pSampleNoRef = NULL;
// Notify the EVR that the frame-step is complete.
NotifyEvent(EC_STEP_COMPLETE, FALSE, 0); // FALSE = completed (not cancelled)
// If we are scrubbing (rate == 0), also send the "scrub time" event.
if (IsScrubbing())
{
// Get the time stamp from the sample.
hr = pSample->GetSampleTime(&hnsSampleTime);
if (FAILED(hr))
{
// No time stamp. Use the current presentation time.
if (m_pClock)
{
hr = m_pClock->GetCorrelatedTime(0, &hnsSampleTime, &hnsSystemTime);
}
hr = S_OK; // Not an error condition.
}
NotifyEvent(EC_SCRUB_TIME, LODWORD(hnsSampleTime), HIDWORD(hnsSampleTime));
}
return hr;
}
void *MMapFile::get(__int64 offset, int *sizep) const
{
if (!sizep)
return NULL;
assert(!m_pView);
int size = *sizep;
if (!m_iSize || offset + size > m_iSize)
{
extern void quit(); extern int g_display_errors;
if (g_display_errors)
{
PrintColorFmtMsg_ERR(_T("\nInternal compiler error #12345: error mmapping file (%I64d, %d) is out of range.\n"), offset, size);
}
quit();
}
// fix offset
__int64 alignedoffset = offset - (offset % m_iAllocationGranularity);
size += offset - alignedoffset;
#ifdef _WIN32
assert(MAKEQWORD(LODWORD(alignedoffset),HIDWORD(alignedoffset)) == alignedoffset);
m_pView = MapViewOfFile(m_hFileMap, m_bReadOnly ? FILE_MAP_READ : FILE_MAP_WRITE, HIDWORD(alignedoffset), LODWORD(alignedoffset), size);
#else
m_pView = mmap(0, size, m_bReadOnly ? PROT_READ : PROT_READ | PROT_WRITE, MAP_SHARED, m_hFileDesc, alignedoffset);
m_iMappedSize = *sizep = size;
#endif
#ifdef _WIN32
if (!m_pView)
#else
if (m_pView == MAP_FAILED)
#endif
{
extern void quit(); extern int g_display_errors;
if (g_display_errors)
{
PrintColorFmtMsg_ERR(_T("\nInternal compiler error #12345: error mmapping datablock to %d.\n"), size);
}
quit();
}
return (void *)((char *)m_pView + offset - alignedoffset);
}
LPVOID GetRelativeBranchDestination(LPVOID lpInst,hdes *hs)
{
#ifdef _AMD64_
return (LPVOID)MAKEDWORDLONG((LODWORD(lpInst)+hs->len+hs->imm.imm32),HIDWORD(lpInst));
#else
return (LPVOID)((DWORD)lpInst+hs->len+hs->imm.imm32);
#endif
}
VOID
MEMvAllocateShared(
PSAllocMap pamMem
)
{
if (!g_bInit)
pamMem->dwRawVAddr = (DWORD)mALLOc((size_t)pamMem->dwRawSize * (size_t)sizeof(BYTE));
/* If allocation failed, virtual/phisical address == NULL */
if ((PVOID)pamMem->dwRawVAddr == NULL) {
LODWORD(pamMem->qwRawPAddr) = 0;
HIDWORD(pamMem->qwRawPAddr) = 0;
return;
} else
memset((PVOID)pamMem->dwRawVAddr, 0, (size_t)pamMem->dwRawSize * (size_t)sizeof(BYTE));
LODWORD(pamMem->qwRawPAddr) = pamMem->dwRawVAddr;
HIDWORD(pamMem->qwRawPAddr) = 0;
}
void
acpi_ut_value_exit (
u32 line_number,
acpi_debug_print_info *dbg_info,
acpi_integer value)
{
acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
"%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str, HIDWORD(value), LODWORD(value));
acpi_gbl_nesting_level--;
}
void CGestures::DumpGesture(LPCWSTR tp, const GESTUREINFO& gi)
{
wchar_t szDump[256];
_wsprintf(szDump, SKIPLEN(countof(szDump))
L"Gesture(x%08X {%i,%i} %s",
(DWORD)gi.hwndTarget, gi.ptsLocation.x, gi.ptsLocation.y,
tp); // tp - имя жеста
switch (gi.dwID)
{
case GID_PRESSANDTAP:
{
DWORD h = LODWORD(gi.ullArguments); _wsprintf(szDump+_tcslen(szDump), SKIPLEN(32)
L" Dist={%i,%i}", (int)(short)LOWORD(h), (int)(short)HIWORD(h));
break;
}
case GID_ROTATE:
{
DWORD h = LODWORD(gi.ullArguments); _wsprintf(szDump+_tcslen(szDump), SKIPLEN(32)
L" %i", (int)LOWORD(h));
break;
}
}
if (gi.dwFlags&GF_BEGIN)
wcscat_c(szDump, L" GF_BEGIN");
if (gi.dwFlags&GF_END)
wcscat_c(szDump, L" GF_END");
if (gi.dwFlags&GF_INERTIA)
{
wcscat_c(szDump, L" GF_INERTIA");
DWORD h = HIDWORD(gi.ullArguments); _wsprintf(szDump+_tcslen(szDump), SKIPLEN(32)
L" {%i,%i}", (int)(short)LOWORD(h), (int)(short)HIWORD(h));
}
if (gpSetCls->isAdvLogging >= 2)
{
gpConEmu->LogString(szDump);
}
else
{
#ifdef USE_DUMPGEST
wcscat_c(szDump, L")\n");
DEBUGSTR(szDump);
#endif
}
}
int MMapFile::setfile(int hFile, __int64 dwSize)
#endif
{
clear();
#ifdef _WIN32
m_hFile = hFile;
#else
m_hFileDesc = hFile;
#endif
m_bTempHandle = FALSE;
#ifdef _WIN32
if (m_hFile == INVALID_HANDLE_VALUE)
#else
if (m_hFileDesc == -1)
#endif
return 0;
m_iSize = dwSize;
if (m_iSize <= 0)
return 0;
#ifdef _WIN32
assert(MAKEQWORD(LODWORD(m_iSize),HIDWORD(m_iSize)) == m_iSize);
m_hFileMap = CreateFileMapping(m_hFile, NULL, PAGE_READONLY, HIDWORD(m_iSize), LODWORD(m_iSize) , NULL);
if (!m_hFileMap)
return 0;
#endif
m_bReadOnly = TRUE;
return 1;
}
acpi_status
acpi_ex_system_io_space_handler (
u32 function,
ACPI_PHYSICAL_ADDRESS address,
u32 bit_width,
u32 *value,
void *handler_context,
void *region_context)
{
acpi_status status = AE_OK;
FUNCTION_TRACE ("Ex_system_io_space_handler");
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"System_iO %d (%d width) Address=%8.8X%8.8X\n", function, bit_width,
HIDWORD (address), LODWORD (address)));
/* Decode the function parameter */
switch (function) {
case ACPI_READ_ADR_SPACE:
*value = 0;
status = acpi_os_read_port ((ACPI_IO_ADDRESS) address, value, bit_width);
break;
case ACPI_WRITE_ADR_SPACE:
status = acpi_os_write_port ((ACPI_IO_ADDRESS) address, *value, bit_width);
break;
default:
status = AE_BAD_PARAMETER;
break;
}
return_ACPI_STATUS (status);
}
//00554540 -> 100%
void CMasterLevelSystem::GCMasterLevelInfo(LPOBJ lpObj) //OK
{
if( !lpObj->m_bMasterLevelDBLoad )
{
this->GDReqMasterLevelInfo(lpObj);
return;
}
// ----
PMSG_MASTERLEVEL_INFO pMsg;
PHeadSubSetB(&pMsg.h.c, 0xF3, 0x50, sizeof(PMSG_MASTERLEVEL_INFO));
// ----
pMsg.nMLevel = lpObj->m_nMasterLevel;
// ----
pMsg.btMLExp1 = SET_NUMBERH(SET_NUMBERHW(HIDWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp2 = SET_NUMBERL(SET_NUMBERHW(HIDWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp3 = SET_NUMBERH(SET_NUMBERLW(HIDWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp4 = SET_NUMBERL(SET_NUMBERLW(HIDWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp5 = SET_NUMBERH(SET_NUMBERHW(LODWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp6 = SET_NUMBERL(SET_NUMBERHW(LODWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp7 = SET_NUMBERH(SET_NUMBERLW(LODWORD(lpObj->m_i64MasterLevelExp)));
pMsg.btMLExp8 = SET_NUMBERL(SET_NUMBERLW(LODWORD(lpObj->m_i64MasterLevelExp)));
// ----
pMsg.btMLNextExp1 = SET_NUMBERH(SET_NUMBERHW(HIDWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp2 = SET_NUMBERL(SET_NUMBERHW(HIDWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp3 = SET_NUMBERH(SET_NUMBERLW(HIDWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp4 = SET_NUMBERL(SET_NUMBERLW(HIDWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp5 = SET_NUMBERH(SET_NUMBERHW(LODWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp6 = SET_NUMBERL(SET_NUMBERHW(LODWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp7 = SET_NUMBERH(SET_NUMBERLW(LODWORD(lpObj->m_i64NextMasterLevelExp)));
pMsg.btMLNextExp8 = SET_NUMBERL(SET_NUMBERLW(LODWORD(lpObj->m_i64NextMasterLevelExp)));
// ----
pMsg.nMLPoint = LOWORD(lpObj->m_iMasterLevelPoint);
pMsg.wMaxLife = (double)lpObj->AddLife + lpObj->MaxLife;
pMsg.wMaxMana = (double)lpObj->AddMana + lpObj->MaxMana;
pMsg.wMaxShield = LOWORD(lpObj->iAddShield) + LOWORD(lpObj->iMaxShield);
pMsg.wMaxBP = LOWORD(lpObj->AddBP) + LOWORD(lpObj->MaxBP);
// ----
DataSend(lpObj->m_Index, (LPBYTE)&pMsg, pMsg.h.size);
}
// -----------------------------------------------------------------------------------------------------------------------------------------
void CSkillTree::SendMasterData(int iIndex)
{
LPOBJ lpObj = &gObj[iIndex];
if ( gUser.gObjIsMasteringLevel(lpObj) == false )
{
return;
}
PMSG_MASTERLEVEL_SEND pMsg;
pMsg.h.set((LPBYTE)&pMsg,0xF3,0x50,sizeof(pMsg));
pMsg.MasterLevel = lpObj->MasterLevel;
pMsg.MasterExp[0] = HIBYTE(HIWORD(HIDWORD(lpObj->MLExperience))); // Highest BYTE
pMsg.MasterExp[1] = LOBYTE(HIWORD(HIDWORD(lpObj->MLExperience)));
pMsg.MasterExp[2] = HIBYTE(LOWORD(HIDWORD(lpObj->MLExperience)));
pMsg.MasterExp[3] = LOBYTE(LOWORD(HIDWORD(lpObj->MLExperience)));
pMsg.MasterExp[4] = HIBYTE(HIWORD(LODWORD(lpObj->MLExperience)));
pMsg.MasterExp[5] = LOBYTE(HIWORD(LODWORD(lpObj->MLExperience)));
pMsg.MasterExp[6] = HIBYTE(LOWORD(LODWORD(lpObj->MLExperience)));
pMsg.MasterExp[7] = LOBYTE(LOWORD(LODWORD(lpObj->MLExperience))); // Lowest BYTE
pMsg.MasterNextExp[0] = HIBYTE(HIWORD(HIDWORD(lpObj->MLNextExp))); // Highest BYTE
pMsg.MasterNextExp[1] = LOBYTE(HIWORD(HIDWORD(lpObj->MLNextExp)));
pMsg.MasterNextExp[2] = HIBYTE(LOWORD(HIDWORD(lpObj->MLNextExp)));
pMsg.MasterNextExp[3] = LOBYTE(LOWORD(HIDWORD(lpObj->MLNextExp)));
pMsg.MasterNextExp[4] = HIBYTE(HIWORD(LODWORD(lpObj->MLNextExp)));
pMsg.MasterNextExp[5] = LOBYTE(HIWORD(LODWORD(lpObj->MLNextExp)));
pMsg.MasterNextExp[6] = HIBYTE(LOWORD(LODWORD(lpObj->MLNextExp)));
pMsg.MasterNextExp[7] = LOBYTE(LOWORD(LODWORD(lpObj->MLNextExp))); // Lowest BYTE
pMsg.MasterPoints = lpObj->MasterPoints;
pMsg.MaxLife = lpObj->MaxLife+lpObj->AddLife;
pMsg.MaxMana = lpObj->MaxMana+lpObj->AddMana;
pMsg.iMaxShield = lpObj->iMaxShield+lpObj->iAddShield;
pMsg.MaxBP = lpObj->MaxBP+lpObj->AddBP;
gSendProto.DataSend(iIndex, (UCHAR*)&pMsg, pMsg.h.size);
}
/*
* Description:
* Set WPA algorithm & keys
*
* Parameters:
* In:
* pDevice -
* param -
* Out:
*
* Return Value:
*
*/
int wpa_set_keys(PSDevice pDevice, void *ctx)
{
struct viawget_wpa_param *param = ctx;
PSMgmtObject pMgmt = &pDevice->sMgmtObj;
DWORD dwKeyIndex = 0;
BYTE abyKey[MAX_KEY_LEN];
BYTE abySeq[MAX_KEY_LEN];
QWORD KeyRSC;
BYTE byKeyDecMode = KEY_CTL_WEP;
int ret = 0;
int uu;
int ii;
if (param->u.wpa_key.alg_name > WPA_ALG_CCMP)
return -EINVAL;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "param->u.wpa_key.alg_name = %d \n",
param->u.wpa_key.alg_name);
if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
pDevice->bEncryptionEnable = FALSE;
pDevice->byKeyIndex = 0;
pDevice->bTransmitKey = FALSE;
for (uu=0; uu<MAX_KEY_TABLE; uu++) {
MACvDisableKeyEntry(pDevice, uu);
}
return ret;
}
if (param->u.wpa_key.key && param->u.wpa_key.key_len > sizeof(abyKey))
return -EINVAL;
memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);
dwKeyIndex = (DWORD)(param->u.wpa_key.key_index);
if (param->u.wpa_key.alg_name == WPA_ALG_WEP) {
if (dwKeyIndex > 3) {
return -EINVAL;
} else {
if (param->u.wpa_key.set_tx) {
pDevice->byKeyIndex = (BYTE)dwKeyIndex;
pDevice->bTransmitKey = TRUE;
dwKeyIndex |= (1 << 31);
}
KeybSetDefaultKey( pDevice,
&(pDevice->sKey),
dwKeyIndex & ~(BIT30 | USE_KEYRSC),
param->u.wpa_key.key_len,
NULL,
abyKey,
KEY_CTL_WEP
);
}
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
pDevice->bEncryptionEnable = TRUE;
return ret;
}
if (param->u.wpa_key.seq && param->u.wpa_key.seq_len > sizeof(abySeq))
return -EINVAL;
memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);
if (param->u.wpa_key.seq_len > 0) {
for (ii = 0 ; ii < param->u.wpa_key.seq_len ; ii++) {
if (ii < 4)
LODWORD(KeyRSC) |= (abySeq[ii] << (ii * 8));
else
HIDWORD(KeyRSC) |= (abySeq[ii] << ((ii-4) * 8));
}
dwKeyIndex |= 1 << 29;
}
if (param->u.wpa_key.key_index >= MAX_GROUP_KEY) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return dwKeyIndex > 3\n");
return -EINVAL;
}
if (param->u.wpa_key.alg_name == WPA_ALG_TKIP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
}
if (param->u.wpa_key.alg_name == WPA_ALG_CCMP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
}
if (param->u.wpa_key.set_tx)
dwKeyIndex |= (1 << 31);
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
byKeyDecMode = KEY_CTL_CCMP;
else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
byKeyDecMode = KEY_CTL_TKIP;
else
byKeyDecMode = KEY_CTL_WEP;
// Fix HCT test that set 256 bits KEY and Ndis802_11Encryption3Enabled
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
if (param->u.wpa_key.key_len == MAX_KEY_LEN)
byKeyDecMode = KEY_CTL_TKIP;
else if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
} else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
}
// Check TKIP key length
if ((byKeyDecMode == KEY_CTL_TKIP) &&
(param->u.wpa_key.key_len != MAX_KEY_LEN)) {
// TKIP Key must be 256 bits
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return - TKIP Key must be 256 bits!\n");
return -EINVAL;
}
// Check AES key length
if ((byKeyDecMode == KEY_CTL_CCMP) &&
(param->u.wpa_key.key_len != AES_KEY_LEN)) {
// AES Key must be 128 bits
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return - AES Key must be 128 bits\n");
return -EINVAL;
}
if (is_broadcast_ether_addr(¶m->addr[0]) || (param->addr == NULL)) {
/* if broadcast, set the key as every key entry's group key */
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Groupe Key Assign.\n");
if ((KeybSetAllGroupKey(pDevice, &(pDevice->sKey), dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(PBYTE)abyKey,
byKeyDecMode
) == TRUE) &&
(KeybSetDefaultKey(pDevice,
&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(PBYTE)abyKey,
byKeyDecMode
) == TRUE) ) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP Key Assign.\n");
} else {
return -EINVAL;
}
} else {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Assign.\n");
// BSSID not 0xffffffffffff
// Pairwise Key can't be WEP
if (byKeyDecMode == KEY_CTL_WEP) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key can't be WEP\n");
return -EINVAL;
}
dwKeyIndex |= (1 << 30); // set pairwise key
if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - WMAC_CONFIG_IBSS_STA\n"));
return -EINVAL;
}
if (KeybSetKey(pDevice, &(pDevice->sKey), ¶m->addr[0],
dwKeyIndex, param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC), (PBYTE)abyKey, byKeyDecMode
) == TRUE) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Set\n");
} else {
// Key Table Full
if (!compare_ether_addr(¶m->addr[0], pDevice->abyBSSID)) {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -Key Table Full.2\n"));
return -EINVAL;
} else {
// Save Key and configure just before associate/reassociate to BSSID
// we do not implement now
return -EINVAL;
}
}
} // BSSID not 0xffffffffffff
if ((ret == 0) && ((param->u.wpa_key.set_tx) != 0)) {
pDevice->byKeyIndex = (BYTE)param->u.wpa_key.key_index;
pDevice->bTransmitKey = TRUE;
}
pDevice->bEncryptionEnable = TRUE;
return ret;
}
int wpa_set_keys(PSDevice pDevice, void *ctx, bool fcpfkernel)
{
struct viawget_wpa_param *param=ctx;
PSMgmtObject pMgmt = pDevice->pMgmt;
unsigned long dwKeyIndex = 0;
unsigned char abyKey[MAX_KEY_LEN];
unsigned char abySeq[MAX_KEY_LEN];
QWORD KeyRSC;
// NDIS_802_11_KEY_RSC KeyRSC;
unsigned char byKeyDecMode = KEY_CTL_WEP;
int ret = 0;
int uu, ii;
if (param->u.wpa_key.alg_name > WPA_ALG_CCMP ||
param->u.wpa_key.key_len >= MAX_KEY_LEN ||
param->u.wpa_key.seq_len >= MAX_KEY_LEN)
return -EINVAL;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "param->u.wpa_key.alg_name = %d \n", param->u.wpa_key.alg_name);
if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
pDevice->bEncryptionEnable = false;
pDevice->byKeyIndex = 0;
pDevice->bTransmitKey = false;
KeyvRemoveAllWEPKey(&(pDevice->sKey), pDevice->PortOffset);
for (uu=0; uu<MAX_KEY_TABLE; uu++) {
MACvDisableKeyEntry(pDevice->PortOffset, uu);
}
return ret;
}
//spin_unlock_irq(&pDevice->lock);
if(param->u.wpa_key.key && fcpfkernel) {
memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);
}
else {
spin_unlock_irq(&pDevice->lock);
if (param->u.wpa_key.key &&
copy_from_user(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len)) {
spin_lock_irq(&pDevice->lock);
return -EINVAL;
}
spin_lock_irq(&pDevice->lock);
}
dwKeyIndex = (unsigned long)(param->u.wpa_key.key_index);
if (param->u.wpa_key.alg_name == WPA_ALG_WEP) {
if (dwKeyIndex > 3) {
return -EINVAL;
}
else {
if (param->u.wpa_key.set_tx) {
pDevice->byKeyIndex = (unsigned char)dwKeyIndex;
pDevice->bTransmitKey = true;
dwKeyIndex |= (1 << 31);
}
KeybSetDefaultKey(&(pDevice->sKey),
dwKeyIndex & ~(BIT30 | USE_KEYRSC),
param->u.wpa_key.key_len,
NULL,
abyKey,
KEY_CTL_WEP,
pDevice->PortOffset,
pDevice->byLocalID);
}
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
pDevice->bEncryptionEnable = true;
return ret;
}
//spin_unlock_irq(&pDevice->lock);
if(param->u.wpa_key.seq && fcpfkernel) {
memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);
}
else {
spin_unlock_irq(&pDevice->lock);
if (param->u.wpa_key.seq &&
copy_from_user(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len)) {
spin_lock_irq(&pDevice->lock);
return -EINVAL;
}
spin_lock_irq(&pDevice->lock);
}
if (param->u.wpa_key.seq_len > 0) {
for (ii = 0 ; ii < param->u.wpa_key.seq_len ; ii++) {
if (ii < 4)
LODWORD(KeyRSC) |= (abySeq[ii] << (ii * 8));
else
HIDWORD(KeyRSC) |= (abySeq[ii] << ((ii-4) * 8));
//KeyRSC |= (abySeq[ii] << (ii * 8));
}
dwKeyIndex |= 1 << 29;
}
if (param->u.wpa_key.key_index >= MAX_GROUP_KEY) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return dwKeyIndex > 3\n");
return -EINVAL;
}
if (param->u.wpa_key.alg_name == WPA_ALG_TKIP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
}
if (param->u.wpa_key.alg_name == WPA_ALG_CCMP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
}
if (param->u.wpa_key.set_tx)
dwKeyIndex |= (1 << 31);
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
byKeyDecMode = KEY_CTL_CCMP;
else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
byKeyDecMode = KEY_CTL_TKIP;
else
byKeyDecMode = KEY_CTL_WEP;
// Fix HCT test that set 256 bits KEY and Ndis802_11Encryption3Enabled
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
if (param->u.wpa_key.key_len == MAX_KEY_LEN)
byKeyDecMode = KEY_CTL_TKIP;
else if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
} else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
}
// Check TKIP key length
if ((byKeyDecMode == KEY_CTL_TKIP) &&
(param->u.wpa_key.key_len != MAX_KEY_LEN)) {
// TKIP Key must be 256 bits
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - TKIP Key must be 256 bits\n"));
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return- TKIP Key must be 256 bits!\n");
return -EINVAL;
}
// Check AES key length
if ((byKeyDecMode == KEY_CTL_CCMP) &&
(param->u.wpa_key.key_len != AES_KEY_LEN)) {
// AES Key must be 128 bits
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - AES Key must be 128 bits\n"));
return -EINVAL;
}
// spin_lock_irq(&pDevice->lock);
if (is_broadcast_ether_addr(¶m->addr[0]) || (param->addr == NULL)) {
// If is_broadcast_ether_addr, set the key as every key entry's group key.
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Groupe Key Assign.\n");
if ((KeybSetAllGroupKey(&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(unsigned char *)abyKey,
byKeyDecMode,
pDevice->PortOffset,
pDevice->byLocalID) == true) &&
(KeybSetDefaultKey(&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(unsigned char *)abyKey,
byKeyDecMode,
pDevice->PortOffset,
pDevice->byLocalID) == true) ) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP Key Assign.\n");
} else {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -KeybSetDefaultKey Fail.0\n"));
// spin_unlock_irq(&pDevice->lock);
return -EINVAL;
}
} else {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Assign.\n");
// BSSID not 0xffffffffffff
// Pairwise Key can't be WEP
if (byKeyDecMode == KEY_CTL_WEP) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key can't be WEP\n");
//spin_unlock_irq(&pDevice->lock);
return -EINVAL;
}
dwKeyIndex |= (1 << 30); // set pairwise key
if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA - WMAC_CONFIG_IBSS_STA\n"));
//spin_unlock_irq(&pDevice->lock);
return -EINVAL;
}
if (KeybSetKey(&(pDevice->sKey),
¶m->addr[0],
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(unsigned char *)abyKey,
byKeyDecMode,
pDevice->PortOffset,
pDevice->byLocalID) == true) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Set\n");
} else {
// Key Table Full
if (!compare_ether_addr(¶m->addr[0], pDevice->abyBSSID)) {
//DBG_PRN_WLAN03(("return NDIS_STATUS_INVALID_DATA -Key Table Full.2\n"));
//spin_unlock_irq(&pDevice->lock);
return -EINVAL;
} else {
// Save Key and configure just before associate/reassociate to BSSID
// we do not implement now
//spin_unlock_irq(&pDevice->lock);
return -EINVAL;
}
}
} // BSSID not 0xffffffffffff
if ((ret == 0) && ((param->u.wpa_key.set_tx) != 0)) {
pDevice->byKeyIndex = (unsigned char)param->u.wpa_key.key_index;
pDevice->bTransmitKey = true;
}
pDevice->bEncryptionEnable = true;
//spin_unlock_irq(&pDevice->lock);
/*
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " key=%x-%x-%x-%x-%x-xxxxx \n",
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][0],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][1],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][2],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][3],
pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[byKeyIndex][4]
);
*/
return ret;
}
void DSSM_BinaryInput<ElemType>::Init(wstring fileName, size_t dim)
{
m_dim = dim;
mbSize = 0;
/*
m_hndl = CreateFileA(fileName.c_str(), GENERIC_READ,
FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
*/
m_hndl = CreateFile(fileName.c_str(), GENERIC_READ,
FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (m_hndl == INVALID_HANDLE_VALUE)
{
char message[256];
sprintf_s(message, "Unable to Open/Create file %ls, error %x", fileName.c_str(), GetLastError());
RuntimeError(message);
}
m_filemap = CreateFileMapping(m_hndl, NULL, PAGE_READONLY, 0, 0, NULL);
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
DWORD sysGran = sysinfo.dwAllocationGranularity;
header_buffer = MapViewOfFile(m_filemap, // handle to map object
FILE_MAP_READ, // get correct permissions
HIDWORD(0),
LODWORD(0),
sizeof(int64_t) * 2 + sizeof(int32_t));
// cout << "After mapviewoffile" << endl;
memcpy(&numRows, header_buffer, sizeof(int64_t));
memcpy(&numCols, (char*) header_buffer + sizeof(int64_t), sizeof(int32_t));
memcpy(&totalNNz, (char*) header_buffer + sizeof(int64_t) + sizeof(int32_t), sizeof(int64_t));
// cout << "After gotvalues" << endl;
int64_t base_offset = sizeof(int64_t) * 2 + sizeof(int32_t);
int64_t offsets_padding = base_offset % sysGran;
base_offset -= offsets_padding;
int64_t header_size = numRows * sizeof(int64_t) + offsets_padding;
void* offsets_orig = MapViewOfFile(m_filemap, // handle to map object
FILE_MAP_READ, // get correct permissions
HIDWORD(base_offset),
LODWORD(base_offset),
header_size);
offsets_buffer = (char*) offsets_orig + offsets_padding;
if (offsets != NULL)
{
free(offsets);
}
offsets = (int64_t*) malloc(sizeof(int64_t) * numRows);
memcpy(offsets, offsets_buffer, numRows * sizeof(int64_t));
int64_t header_offset = base_offset + offsets_padding + numRows * sizeof(int64_t);
int64_t data_padding = header_offset % sysGran;
header_offset -= data_padding;
void* data_orig = MapViewOfFile(m_filemap, // handle to map object
FILE_MAP_READ, // get correct permissions
HIDWORD(header_offset),
LODWORD(header_offset),
0);
data_buffer = (char*) data_orig + data_padding;
}
static ULONGLONG UnsignedMultiplyHigh( ULONGLONG ull1, ULONGLONG ull2 )
{
return HIDWORD( ull1 ) * HIDWORD( ull2 ) + HIDWORD( HIDWORD( ull1 )
* LODWORD( ull2 ) + LODWORD( ull1 ) * HIDWORD( ull2 )
+ HIDWORD( LODWORD( ull1 ) * LODWORD( ull2 ) ) );
}
DWORD FileDetailsReadMap(const TCHAR* filePath, QWORD& qwSize, FILETIME& fileTime, DWORD& dwCheckSum
, HANDLE evAbort) // bool volatile * pisAbort)
{
_ASSERTE(filePath);
_ASSERTE(lstrlen(filePath));
DWORD dwCrc32;
DWORD dwErrorCode = NO_ERROR;
HANDLE hFile = NULL, hFilemap = NULL;
dwCrc32 = 0x0;
LPBYTE pCrc = (LPBYTE)&dwCrc32;
FILETIME fileTime0;
QWORD qwFileSize, qwFileSize0;
try
{
// Open the file
hFile = CreateFile(filePath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if(hFile == INVALID_HANDLE_VALUE)
throw GetLastErrorEx;
QWORD qwFileOffset = 0;
DWORD dwByteCount, dwViewSize;
LPVOID dwBaseAddress;
{
DWORD dwLo = 0, dwHi = 0;
dwLo = GetFileSize(hFile, &dwHi);
if(dwLo == INVALID_FILE_SIZE
&& (dwErrorCode = GetLastError()) != NO_ERROR)
throw ExitEx;
qwFileSize = qwFileSize0 = MAKEQWORD(dwHi, dwLo);
}
if (!GetFileTime(hFile, &fileTime0, NULL, NULL))
throw GetLastErrorEx;
// Get the file size
//if(!GetFileSizeQW(hFile, qwFileSize))
// dwErrorCode = ERROR_BAD_LENGTH;
//else
if(0 != qwFileSize) // We cannot CRC zero byte files
{
// Create the file mapping
hFilemap = CreateFileMapping(hFile,
NULL,
PAGE_READONLY,
0,
0,
NULL);
if(NULL == hFilemap)
throw GetLastErrorEx;
LPBYTE pByte;
//LPDWORD pDWord;
// Loop while we map a section of the file and CRC it
while(0 < qwFileSize)
{
//if (*pisAbort)
if (WaitForSingleObject(evAbort, 0) != WAIT_TIMEOUT)
{
dwErrorCode = ERROR_CANCELLED;
throw ExitEx;
}
if(qwFileSize < MAX_VIEW_SIZE)
dwViewSize = LODWORD(qwFileSize);
else
dwViewSize = MAX_VIEW_SIZE;
dwBaseAddress = MapViewOfFile(hFilemap,
FILE_MAP_READ,
HIDWORD(qwFileOffset),
LODWORD(qwFileOffset),
dwViewSize);
dwByteCount = dwViewSize;
pByte = (LPBYTE)dwBaseAddress;
BYTE checkSumOffset = 0;
while(0 < dwByteCount--)
{
*(pCrc + checkSumOffset) ^= *pByte;
pByte++;
checkSumOffset++;
if (4 <= checkSumOffset)
checkSumOffset = 0;
}
UnmapViewOfFile((LPVOID)dwBaseAddress);
qwFileOffset += dwViewSize;
qwFileSize -= dwViewSize;
} // while(qwFileSize > 0)
} // if(qwFileSize != 0)
}
catch(char c)
{
if (GetLastErrorEx == c)
dwErrorCode = GetLastError();
}
catch(...)
{
// An unknown exception happened
dwErrorCode = ERROR_CRC;
}
if(hFile != NULL) CloseHandle(hFile);
if(hFilemap != NULL) CloseHandle(hFilemap);
if (NO_ERROR == dwErrorCode)
{
qwSize = qwFileSize0;
dwCheckSum = dwCrc32;
fileTime = fileTime0;
}
return dwErrorCode;
}
OsStatus_t
AhciCommandDispatch(
_In_ AhciTransaction_t* Transaction,
_In_ Flags_t Flags,
_In_ void* Command,
_In_ size_t CommandLength,
_In_ void* AtapiCommand,
_In_ size_t AtapiCommandLength)
{
AHCICommandHeader_t* CommandHeader;
AHCICommandTable_t* CommandTable;
uintptr_t BufferPointer;
size_t BytesLeft = Transaction->SectorCount * Transaction->Device->SectorSize;
int PrdtIndex = 0;
TRACE("AhciCommandDispatch(Port %u, Flags 0x%x, Length %u, TransferSize 0x%x)",
Transaction->Device->Port->Id, Flags, CommandLength, BytesLeft);
// Assert that buffer is DWORD aligned, this must be true
if (((uintptr_t)Transaction->Address & 0x3) != 0) {
ERROR("AhciCommandDispatch::Buffer was not dword aligned (0x%x)",
Transaction->Device->Port->Id, Transaction->Address);
goto Error;
}
// Assert that buffer length is an even byte-count requested
if ((BytesLeft & 0x1) != 0) {
ERROR("AhciCommandDispatch::BufferLength is odd, must be even",
Transaction->Device->Port->Id);
goto Error;
}
// Get a reference to the command slot and reset the data in the command table
CommandHeader = &Transaction->Device->Port->CommandList->Headers[Transaction->Slot];
CommandTable = (AHCICommandTable_t*)((uint8_t*)Transaction->Device->Port->CommandTable
+ (AHCI_COMMAND_TABLE_SIZE * Transaction->Slot));
memset(CommandTable, 0, AHCI_COMMAND_TABLE_SIZE);
// Sanitizie packet lenghts
if (CommandLength > 64 || AtapiCommandLength > 16) {
ERROR("AHCI::Commands are exceeding the allowed length, FIS (%u), ATAPI (%u)",
CommandLength, AtapiCommandLength);
goto Error;
}
// Copy data over into the packets based on type
if (Command != NULL) {
memcpy(&CommandTable->FISCommand[0], Command, CommandLength);
}
if (AtapiCommand != NULL) {
memcpy(&CommandTable->FISAtapi[0], AtapiCommand, AtapiCommandLength);
}
// Build PRDT entries
TRACE("Building PRDT Table");
BufferPointer = Transaction->Address;
while (BytesLeft > 0) {
AHCIPrdtEntry_t* Prdt = &CommandTable->PrdtEntry[PrdtIndex];
size_t TransferLength = MIN(AHCI_PRDT_MAX_LENGTH, BytesLeft);
// Set buffer information and transfer sizes
Prdt->DataBaseAddress = LODWORD(BufferPointer);
Prdt->DataBaseAddressUpper = (sizeof(void*) > 4) ? HIDWORD(BufferPointer) : 0;
Prdt->Descriptor = TransferLength - 1; // N - 1
TRACE("PRDT %u, Address 0x%x, Length 0x%x", PrdtIndex, Prdt->DataBaseAddress, Prdt->Descriptor);
// Adjust counters
BufferPointer += TransferLength;
BytesLeft -= TransferLength;
PrdtIndex++;
// If this is the last PRDT packet, set IOC
if (BytesLeft == 0) {
Prdt->Descriptor |= AHCI_PRDT_IOC;
}
}
// Update command table to the new command
CommandHeader->PRDByteCount = 0;
CommandHeader->TableLength = (uint16_t)PrdtIndex;
CommandHeader->Flags = (uint16_t)(CommandLength >> 2);
TRACE("PRDT Count %u, Number of DW's %u", CommandHeader->TableLength, CommandHeader->Flags);
// Update transfer with the dispatch flags
if (Flags & DISPATCH_ATAPI) {
CommandHeader->Flags |= (1 << 5);
}
if (Flags & DISPATCH_WRITE) {
CommandHeader->Flags |= (1 << 6);
}
if (Flags & DISPATCH_PREFETCH) {
CommandHeader->Flags |= (1 << 7);
}
if (Flags & DISPATCH_CLEARBUSY) {
CommandHeader->Flags |= (1 << 10);
}
// Set the port multiplier
CommandHeader->Flags |= (DISPATCH_MULTIPLIER(Flags) << 12);
Transaction->Header.Key.Value.Integer = Transaction->Slot;
// Add transaction to list
CollectionAppend(Transaction->Device->Port->Transactions, &Transaction->Header);
TRACE("Enabling command on slot %u", Transaction->Slot);
AhciPortStartCommandSlot(Transaction->Device->Port, Transaction->Slot);
#ifdef __TRACE
// Dump state
thrd_sleepex(5000);
AhciDumpCurrentState(Transaction->Device->Controller, Transaction->Device->Port);
#endif
return OsSuccess;
Error:
return OsError;
}
_WCRTLINK __int64 __lseeki64( int handle, __int64 offset, int origin )
{
#if defined( __NT__ ) || defined( __OS2__ ) || defined( __LINUX__ )
__int64 pos;
__handle_check( handle, -1 );
#if defined( __OS2__ )
{
#if !defined( _M_I86 )
APIRET rc;
if( __os2_DosSetFilePtrL != NULL ) {
rc = __os2_DosSetFilePtrL( handle, offset, origin, &pos );
if( rc != 0 ) {
return( __set_errno_dos( rc ) );
}
} else {
#endif
if( offset > LONG_MAX || offset < LONG_MIN ) {
__set_errno( EINVAL );
return( -1LL );
}
pos = (unsigned long)__lseek( handle, offset, origin );
if( pos == INVALID_SET_FILE_POINTER ) {
pos = -1LL;
}
#if !defined( _M_I86 )
}
#endif
}
#elif defined( __NT__ )
{
DWORD rc;
LONG offset_hi;
int error;
offset_hi = HIDWORD( offset );
rc = SetFilePointer( __getOSHandle( handle ), LODWORD( offset ), &offset_hi, origin );
if( rc == INVALID_SET_FILE_POINTER ) { // this might be OK so
error = GetLastError(); // check for sure JBS 04-nov-99
if( error != NO_ERROR ) {
return( __set_errno_dos( error ) );
}
}
U64Set( (unsigned_64 *)&pos, rc, offset_hi );
}
#elif defined( __LINUX__ )
if( _llseek( handle, LODWORD( offset ), HIDWORD( offset ), &pos, origin ) ) {
pos = -1LL;
}
#endif
return( pos );
#else
long pos;
if( offset > LONG_MAX || offset < LONG_MIN ) {
__set_errno( EINVAL );
return( -1LL );
}
pos = __lseek( handle, offset, origin );
if( pos == INVALID_SET_FILE_POINTER ) {
return( -1LL );
}
return( (unsigned long)pos );
#endif
}
void
acpi_db_dump_object (
acpi_object *obj_desc,
u32 level)
{
u32 i;
if (!obj_desc) {
acpi_os_printf ("[Null Object]\n");
return;
}
for (i = 0; i < level; i++) {
acpi_os_printf (" ");
}
switch (obj_desc->type) {
case ACPI_TYPE_ANY:
acpi_os_printf ("[Object Reference] = %p\n", obj_desc->reference.handle);
break;
case ACPI_TYPE_INTEGER:
acpi_os_printf ("[Integer] = %8.8X%8.8X\n", HIDWORD (obj_desc->integer.value),
LODWORD (obj_desc->integer.value));
break;
case ACPI_TYPE_STRING:
acpi_os_printf ("[String] Value: ");
for (i = 0; i < obj_desc->string.length; i++) {
acpi_os_printf ("%c", obj_desc->string.pointer[i]);
}
acpi_os_printf ("\n");
break;
case ACPI_TYPE_BUFFER:
acpi_os_printf ("[Buffer] = ");
acpi_ut_dump_buffer ((u8 *) obj_desc->buffer.pointer, obj_desc->buffer.length, DB_DWORD_DISPLAY, _COMPONENT);
break;
case ACPI_TYPE_PACKAGE:
acpi_os_printf ("[Package] Contains %d Elements: \n", obj_desc->package.count);
for (i = 0; i < obj_desc->package.count; i++) {
acpi_db_dump_object (&obj_desc->package.elements[i], level+1);
}
break;
case INTERNAL_TYPE_REFERENCE:
acpi_os_printf ("[Object Reference] = %p\n", obj_desc->reference.handle);
break;
case ACPI_TYPE_PROCESSOR:
acpi_os_printf ("[Processor]\n");
break;
case ACPI_TYPE_POWER:
acpi_os_printf ("[Power Resource]\n");
break;
default:
acpi_os_printf ("[Unknown Type] %X \n", obj_desc->type);
break;
}
}
__ptr_t
__mmap64 (__ptr_t addr, size_t len, int prot, int flags, int fd,
__off64_t offset)
{
__ptr_t map = (__ptr_t) NULL;
caddr_t gran_addr = (caddr_t) addr;
HANDLE handle = INVALID_HANDLE_VALUE;
DWORD cfm_flags = 0, mvf_flags = 0, sysgran = getgranularity ();
__off64_t gran_offset = offset, filelen = _filelengthi64(fd);
int mmlen = len;
switch (prot) {
case PROT_READ | PROT_WRITE | PROT_EXEC:
case PROT_WRITE | PROT_EXEC:
cfm_flags = PAGE_EXECUTE_READWRITE;
mvf_flags = FILE_MAP_ALL_ACCESS;
break;
case PROT_READ | PROT_WRITE:
cfm_flags = PAGE_READWRITE;
mvf_flags = FILE_MAP_ALL_ACCESS;
break;
case PROT_WRITE:
cfm_flags = PAGE_READWRITE;
mvf_flags = FILE_MAP_WRITE;
break;
case PROT_READ:
cfm_flags = PAGE_READONLY;
mvf_flags = FILE_MAP_READ;
break;
case PROT_NONE:
cfm_flags = PAGE_NOACCESS;
mvf_flags = FILE_MAP_READ;
break;
case PROT_EXEC:
cfm_flags = PAGE_EXECUTE;
mvf_flags = FILE_MAP_READ;
break;
}
if (flags & MAP_PRIVATE) {
if (IsWin9x ())
cfm_flags = PAGE_WRITECOPY;
mvf_flags = FILE_MAP_COPY;
}
fprintf (stderr, "Addr before: %p\n", gran_addr);
fprintf (stderr, "Offset before: %#I64X\n", gran_offset);
if (flags & MAP_FIXED) {
gran_offset = offset;
gran_addr = addr;
}
else {
gran_offset = offset & ~(sysgran - 1);
gran_addr = (caddr_t) (((DWORD) gran_addr / sysgran) * sysgran);
}
fprintf (stderr, "Addr after: %p\n", gran_addr);
fprintf (stderr, "Offset after: %#I64X\n", gran_offset);
mmlen = (filelen < gran_offset + len ? filelen - gran_offset : len);
handle = CreateFileMapping ((HANDLE) _get_osfhandle(fd), NULL, cfm_flags,
0, mmlen, NULL);
if (!handle) {
set_werrno;
WinErr ("CreateFileMapping");
return MAP_FAILED;
}
map = (__ptr_t) MapViewOfFileEx (handle, mvf_flags, HIDWORD(gran_offset),
LODWORD(gran_offset), (SIZE_T) mmlen, (LPVOID) gran_addr);
if (map == NULL && (flags & MAP_FIXED) ) {
fprintf (stderr, "Starting address: %p\n", (LPVOID) gran_addr);
WinErr ("First try of MapViewOfFileEx failed");
map = (__ptr_t) MapViewOfFileEx (handle, mvf_flags, HIDWORD(gran_offset),
LODWORD(gran_offset), (SIZE_T) mmlen, (LPVOID) NULL);
}
CloseHandle(handle);
if (map == NULL) {
set_werrno;
WinErr ("MapViewOfFileEx");
return MAP_FAILED;
}
return map;
}
bool CPluginW2800::GetPanelItemInfo(const CEPanelInfo& PnlInfo, bool bSelected, INT_PTR iIndex, WIN32_FIND_DATAW& Info, wchar_t** ppszFullPathName)
{
if (!InfoW2800 || !InfoW2800->PanelControl)
return false;
FILE_CONTROL_COMMANDS iCmd = bSelected ? FCTL_GETSELECTEDPANELITEM : FCTL_GETPANELITEM;
INT_PTR iItemsNumber = bSelected ? ((PanelInfo*)PnlInfo.panelInfo)->SelectedItemsNumber : ((PanelInfo*)PnlInfo.panelInfo)->ItemsNumber;
if ((iIndex < 0) || (iIndex >= iItemsNumber))
{
_ASSERTE(FALSE && "iItem out of bounds");
return false;
}
INT_PTR sz = PanelControlApi(PANEL_ACTIVE, iCmd, iIndex, NULL);
if (sz <= 0)
return false;
PluginPanelItem* pItem = (PluginPanelItem*)calloc(sz, 1); // размер возвращается в байтах
if (!pItem)
return false;
FarGetPluginPanelItem gppi = {sizeof(gppi), sz, pItem};
if (PanelControlApi(PANEL_ACTIVE, iCmd, iIndex, &gppi) <= 0)
{
free(pItem);
return false;
}
ZeroStruct(Info);
Info.dwFileAttributes = LODWORD(pItem->FileAttributes);
Info.ftCreationTime = pItem->CreationTime;
Info.ftLastAccessTime = pItem->LastAccessTime;
Info.ftLastWriteTime = pItem->LastWriteTime;
Info.nFileSizeLow = LODWORD(pItem->FileSize);
Info.nFileSizeHigh = HIDWORD(pItem->FileSize);
if (pItem->FileName)
{
LPCWSTR pszName = pItem->FileName;
int iLen = lstrlen(pszName);
// If full paths exceeds MAX_PATH chars - return in Info.cFileName the file name only
if (iLen >= countof(Info.cFileName))
pszName = PointToName(pItem->FileName);
lstrcpyn(Info.cFileName, pszName, countof(Info.cFileName));
if (ppszFullPathName)
*ppszFullPathName = lstrdup(pItem->FileName);
}
else if (ppszFullPathName)
{
_ASSERTE(*ppszFullPathName == NULL);
*ppszFullPathName = NULL;
}
if (pItem->AlternateFileName)
{
lstrcpyn(Info.cAlternateFileName, pItem->AlternateFileName, countof(Info.cAlternateFileName));
}
free(pItem);
return true;
}
acpi_status
acpi_ex_system_memory_space_handler (
u32 function,
ACPI_PHYSICAL_ADDRESS address,
u32 bit_width,
u32 *value,
void *handler_context,
void *region_context)
{
acpi_status status = AE_OK;
void *logical_addr_ptr = NULL;
acpi_mem_space_context *mem_info = region_context;
u32 length;
FUNCTION_TRACE ("Ex_system_memory_space_handler");
/* Validate and translate the bit width */
switch (bit_width) {
case 8:
length = 1;
break;
case 16:
length = 2;
break;
case 32:
length = 4;
break;
default:
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid System_memory width %d\n",
bit_width));
return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
break;
}
/*
* Does the request fit into the cached memory mapping?
* Is 1) Address below the current mapping? OR
* 2) Address beyond the current mapping?
*/
if ((address < mem_info->mapped_physical_address) ||
(((acpi_integer) address + length) >
((acpi_integer) mem_info->mapped_physical_address + mem_info->mapped_length))) {
/*
* The request cannot be resolved by the current memory mapping;
* Delete the existing mapping and create a new one.
*/
if (mem_info->mapped_length) {
/* Valid mapping, delete it */
acpi_os_unmap_memory (mem_info->mapped_logical_address,
mem_info->mapped_length);
}
mem_info->mapped_length = 0; /* In case of failure below */
/* Create a new mapping starting at the address given */
status = acpi_os_map_memory (address, SYSMEM_REGION_WINDOW_SIZE,
(void **) &mem_info->mapped_logical_address);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
}
/* Save the physical address and mapping size */
mem_info->mapped_physical_address = address;
mem_info->mapped_length = SYSMEM_REGION_WINDOW_SIZE;
}
/*
* Generate a logical pointer corresponding to the address we want to
* access
*/
/* TBD: should these pointers go to 64-bit in all cases ? */
logical_addr_ptr = mem_info->mapped_logical_address +
((acpi_integer) address - (acpi_integer) mem_info->mapped_physical_address);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"System_memory %d (%d width) Address=%8.8X%8.8X\n", function, bit_width,
HIDWORD (address), LODWORD (address)));
/* Perform the memory read or write */
switch (function) {
case ACPI_READ_ADR_SPACE:
switch (bit_width) {
case 8:
*value = (u32)* (u8 *) logical_addr_ptr;
break;
case 16:
MOVE_UNALIGNED16_TO_32 (value, logical_addr_ptr);
break;
case 32:
MOVE_UNALIGNED32_TO_32 (value, logical_addr_ptr);
break;
}
break;
case ACPI_WRITE_ADR_SPACE:
switch (bit_width) {
case 8:
*(u8 *) logical_addr_ptr = (u8) *value;
break;
case 16:
MOVE_UNALIGNED16_TO_16 (logical_addr_ptr, value);
break;
case 32:
MOVE_UNALIGNED32_TO_32 (logical_addr_ptr, value);
break;
}
break;
default:
status = AE_BAD_PARAMETER;
break;
}
return_ACPI_STATUS (status);
}
void MMapFile::resize(__int64 newsize)
{
release();
if (newsize > m_iSize)
{
#ifdef _WIN32
if (m_hFileMap)
CloseHandle(m_hFileMap);
m_hFileMap = 0;
#endif
m_iSize = newsize;
#ifdef _WIN32
if (m_hFile == INVALID_HANDLE_VALUE)
{
TCHAR buf[MAX_PATH], buf2[MAX_PATH];
GetTempPath(MAX_PATH, buf);
GetTempFileName(buf, _T("nsd"), 0, buf2);
m_hFile = CreateFile(
buf2,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE | FILE_FLAG_SEQUENTIAL_SCAN,
NULL
);
m_bTempHandle = TRUE;
}
if (m_hFile != INVALID_HANDLE_VALUE)
{
m_hFileMap = CreateFileMapping(
m_hFile,
NULL,
m_bReadOnly ? PAGE_READONLY : PAGE_READWRITE,
HIDWORD(m_iSize),
LODWORD(m_iSize),
NULL
);
}
#else
if (m_hFile == NULL)
{
m_hFile = tmpfile();
if (m_hFile != NULL)
{
m_hFileDesc = fileno(m_hFile);
m_bTempHandle = TRUE;
}
}
// resize
if (m_hFileDesc != -1)
{
unsigned char c = 0;
if (lseek(m_hFileDesc, m_iSize, SEEK_SET) != (off_t)-1)
{
if (read(m_hFileDesc, &c, 1) != -1)
{
if (lseek(m_hFileDesc, m_iSize, SEEK_SET) != (off_t)-1)
{
if (write(m_hFileDesc, &c, 1) != -1)
{
return; // no errors
}
}
}
}
}
m_hFileDesc = -1; // some error occurred, bail
#endif
#ifdef _WIN32
if (!m_hFileMap)
#else
if (m_hFileDesc == -1)
#endif
{
extern void quit(); extern int g_display_errors;
if (g_display_errors)
{
PrintColorFmtMsg_ERR(_T("\nInternal compiler error #12345: error creating mmap the size of %I64d.\n"), m_iSize);
}
quit();
}
}
}
bool
device_receive_frame(
PSDevice pDevice,
PSRxDesc pCurrRD
)
{
PDEVICE_RD_INFO pRDInfo = pCurrRD->pRDInfo;
struct net_device_stats *pStats = &pDevice->stats;
struct sk_buff *skb;
PSMgmtObject pMgmt = pDevice->pMgmt;
PSRxMgmtPacket pRxPacket = &(pDevice->pMgmt->sRxPacket);
PS802_11Header p802_11Header;
unsigned char *pbyRsr;
unsigned char *pbyNewRsr;
unsigned char *pbyRSSI;
PQWORD pqwTSFTime;
unsigned short *pwFrameSize;
unsigned char *pbyFrame;
bool bDeFragRx = false;
bool bIsWEP = false;
unsigned int cbHeaderOffset;
unsigned int FrameSize;
unsigned short wEtherType = 0;
int iSANodeIndex = -1;
int iDANodeIndex = -1;
unsigned int ii;
unsigned int cbIVOffset;
bool bExtIV = false;
unsigned char *pbyRxSts;
unsigned char *pbyRxRate;
unsigned char *pbySQ;
unsigned int cbHeaderSize;
PSKeyItem pKey = NULL;
unsigned short wRxTSC15_0 = 0;
unsigned long dwRxTSC47_16 = 0;
SKeyItem STempKey;
// 802.11h RPI
unsigned long dwDuration = 0;
long ldBm = 0;
long ldBmThreshold = 0;
PS802_11Header pMACHeader;
bool bRxeapol_key = false;
skb = pRDInfo->skb;
//PLICE_DEBUG->
pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
//PLICE_DEBUG<-
pwFrameSize = (unsigned short *)(skb->data + 2);
FrameSize = cpu_to_le16(pCurrRD->m_rd1RD1.wReqCount) - cpu_to_le16(pCurrRD->m_rd0RD0.wResCount);
// Max: 2312Payload + 30HD +4CRC + 2Padding + 4Len + 8TSF + 4RSR
// Min (ACK): 10HD +4CRC + 2Padding + 4Len + 8TSF + 4RSR
if ((FrameSize > 2364) || (FrameSize <= 32)) {
// Frame Size error drop this packet.
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---------- WRONG Length 1\n");
return false;
}
pbyRxSts = (unsigned char *)(skb->data);
pbyRxRate = (unsigned char *)(skb->data + 1);
pbyRsr = (unsigned char *)(skb->data + FrameSize - 1);
pbyRSSI = (unsigned char *)(skb->data + FrameSize - 2);
pbyNewRsr = (unsigned char *)(skb->data + FrameSize - 3);
pbySQ = (unsigned char *)(skb->data + FrameSize - 4);
pqwTSFTime = (PQWORD)(skb->data + FrameSize - 12);
pbyFrame = (unsigned char *)(skb->data + 4);
// get packet size
FrameSize = cpu_to_le16(*pwFrameSize);
if ((FrameSize > 2346)|(FrameSize < 14)) { // Max: 2312Payload + 30HD +4CRC
// Min: 14 bytes ACK
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---------- WRONG Length 2\n");
return false;
}
//PLICE_DEBUG->
// update receive statistic counter
STAvUpdateRDStatCounter(&pDevice->scStatistic,
*pbyRsr,
*pbyNewRsr,
*pbyRxRate,
pbyFrame,
FrameSize);
pMACHeader = (PS802_11Header)((unsigned char *)(skb->data) + 8);
//PLICE_DEBUG<-
if (pDevice->bMeasureInProgress) {
if ((*pbyRsr & RSR_CRCOK) != 0)
pDevice->byBasicMap |= 0x01;
dwDuration = (FrameSize << 4);
dwDuration /= acbyRxRate[*pbyRxRate%MAX_RATE];
if (*pbyRxRate <= RATE_11M) {
if (*pbyRxSts & 0x01) {
// long preamble
dwDuration += 192;
} else {
// short preamble
dwDuration += 96;
}
} else {
dwDuration += 16;
}
RFvRSSITodBm(pDevice, *pbyRSSI, &ldBm);
ldBmThreshold = -57;
for (ii = 7; ii > 0;) {
if (ldBm > ldBmThreshold)
break;
ldBmThreshold -= 5;
ii--;
}
pDevice->dwRPIs[ii] += dwDuration;
return false;
}
if (!is_multicast_ether_addr(pbyFrame)) {
if (WCTLbIsDuplicate(&(pDevice->sDupRxCache), (PS802_11Header)(skb->data + 4))) {
pDevice->s802_11Counter.FrameDuplicateCount++;
return false;
}
}
// Use for TKIP MIC
s_vGetDASA(skb->data+4, &cbHeaderSize, &pDevice->sRxEthHeader);
// filter packet send from myself
if (ether_addr_equal(pDevice->sRxEthHeader.abySrcAddr,
pDevice->abyCurrentNetAddr))
return false;
if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) || (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)) {
if (IS_CTL_PSPOLL(pbyFrame) || !IS_TYPE_CONTROL(pbyFrame)) {
p802_11Header = (PS802_11Header)(pbyFrame);
// get SA NodeIndex
if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(p802_11Header->abyAddr2), &iSANodeIndex)) {
pMgmt->sNodeDBTable[iSANodeIndex].ulLastRxJiffer = jiffies;
pMgmt->sNodeDBTable[iSANodeIndex].uInActiveCount = 0;
}
}
}
if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
if (s_bAPModeRxCtl(pDevice, pbyFrame, iSANodeIndex))
return false;
}
if (IS_FC_WEP(pbyFrame)) {
bool bRxDecryOK = false;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "rx WEP pkt\n");
bIsWEP = true;
if ((pDevice->bEnableHostWEP) && (iSANodeIndex >= 0)) {
pKey = &STempKey;
pKey->byCipherSuite = pMgmt->sNodeDBTable[iSANodeIndex].byCipherSuite;
pKey->dwKeyIndex = pMgmt->sNodeDBTable[iSANodeIndex].dwKeyIndex;
pKey->uKeyLength = pMgmt->sNodeDBTable[iSANodeIndex].uWepKeyLength;
pKey->dwTSC47_16 = pMgmt->sNodeDBTable[iSANodeIndex].dwTSC47_16;
pKey->wTSC15_0 = pMgmt->sNodeDBTable[iSANodeIndex].wTSC15_0;
memcpy(pKey->abyKey,
&pMgmt->sNodeDBTable[iSANodeIndex].abyWepKey[0],
pKey->uKeyLength
);
bRxDecryOK = s_bHostWepRxEncryption(pDevice,
pbyFrame,
FrameSize,
pbyRsr,
pMgmt->sNodeDBTable[iSANodeIndex].bOnFly,
pKey,
pbyNewRsr,
&bExtIV,
&wRxTSC15_0,
&dwRxTSC47_16);
} else {
bRxDecryOK = s_bHandleRxEncryption(pDevice,
pbyFrame,
FrameSize,
pbyRsr,
pbyNewRsr,
&pKey,
&bExtIV,
&wRxTSC15_0,
&dwRxTSC47_16);
}
if (bRxDecryOK) {
if ((*pbyNewRsr & NEWRSR_DECRYPTOK) == 0) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ICV Fail\n");
if ((pDevice->pMgmt->eAuthenMode == WMAC_AUTH_WPA) ||
(pDevice->pMgmt->eAuthenMode == WMAC_AUTH_WPAPSK) ||
(pDevice->pMgmt->eAuthenMode == WMAC_AUTH_WPANONE) ||
(pDevice->pMgmt->eAuthenMode == WMAC_AUTH_WPA2) ||
(pDevice->pMgmt->eAuthenMode == WMAC_AUTH_WPA2PSK)) {
if ((pKey != NULL) && (pKey->byCipherSuite == KEY_CTL_TKIP))
pDevice->s802_11Counter.TKIPICVErrors++;
else if ((pKey != NULL) && (pKey->byCipherSuite == KEY_CTL_CCMP))
pDevice->s802_11Counter.CCMPDecryptErrors++;
}
return false;
}
} else {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "WEP Func Fail\n");
return false;
}
if ((pKey != NULL) && (pKey->byCipherSuite == KEY_CTL_CCMP))
FrameSize -= 8; // Message Integrity Code
else
FrameSize -= 4; // 4 is ICV
}
//
// RX OK
//
//remove the CRC length
FrameSize -= ETH_FCS_LEN;
if ((!(*pbyRsr & (RSR_ADDRBROAD | RSR_ADDRMULTI))) && // unicast address
(IS_FRAGMENT_PKT((skb->data+4)))
) {
// defragment
bDeFragRx = WCTLbHandleFragment(pDevice, (PS802_11Header)(skb->data+4), FrameSize, bIsWEP, bExtIV);
pDevice->s802_11Counter.ReceivedFragmentCount++;
if (bDeFragRx) {
// defrag complete
skb = pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].skb;
FrameSize = pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].cbFrameLength;
} else {
return false;
}
}
// Management & Control frame Handle
if ((IS_TYPE_DATA((skb->data+4))) == false) {
// Handle Control & Manage Frame
if (IS_TYPE_MGMT((skb->data+4))) {
unsigned char *pbyData1;
unsigned char *pbyData2;
pRxPacket->p80211Header = (PUWLAN_80211HDR)(skb->data+4);
pRxPacket->cbMPDULen = FrameSize;
pRxPacket->uRSSI = *pbyRSSI;
pRxPacket->bySQ = *pbySQ;
HIDWORD(pRxPacket->qwLocalTSF) = cpu_to_le32(HIDWORD(*pqwTSFTime));
LODWORD(pRxPacket->qwLocalTSF) = cpu_to_le32(LODWORD(*pqwTSFTime));
if (bIsWEP) {
// strip IV
pbyData1 = WLAN_HDR_A3_DATA_PTR(skb->data+4);
pbyData2 = WLAN_HDR_A3_DATA_PTR(skb->data+4) + 4;
for (ii = 0; ii < (FrameSize - 4); ii++) {
*pbyData1 = *pbyData2;
pbyData1++;
pbyData2++;
}
}
pRxPacket->byRxRate = s_byGetRateIdx(*pbyRxRate);
pRxPacket->byRxChannel = (*pbyRxSts) >> 2;
vMgrRxManagePacket((void *)pDevice, pDevice->pMgmt, pRxPacket);
// hostap Deamon handle 802.11 management
if (pDevice->bEnableHostapd) {
skb->dev = pDevice->apdev;
skb->data += 4;
skb->tail += 4;
skb_put(skb, FrameSize);
skb_reset_mac_header(skb);
skb->pkt_type = PACKET_OTHERHOST;
skb->protocol = htons(ETH_P_802_2);
memset(skb->cb, 0, sizeof(skb->cb));
netif_rx(skb);
return true;
}
}
return false;
} else {
int wpa_set_keys(PSDevice pDevice, void *ctx, bool fcpfkernel)
{
struct viawget_wpa_param *param=ctx;
PSMgmtObject pMgmt = pDevice->pMgmt;
unsigned long dwKeyIndex = 0;
unsigned char abyKey[MAX_KEY_LEN];
unsigned char abySeq[MAX_KEY_LEN];
QWORD KeyRSC;
unsigned char byKeyDecMode = KEY_CTL_WEP;
int ret = 0;
int uu, ii;
if (param->u.wpa_key.alg_name > WPA_ALG_CCMP ||
param->u.wpa_key.key_len >= MAX_KEY_LEN ||
param->u.wpa_key.seq_len >= MAX_KEY_LEN)
return -EINVAL;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "param->u.wpa_key.alg_name = %d \n", param->u.wpa_key.alg_name);
if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
pDevice->bEncryptionEnable = false;
pDevice->byKeyIndex = 0;
pDevice->bTransmitKey = false;
KeyvRemoveAllWEPKey(&(pDevice->sKey), pDevice->PortOffset);
for (uu=0; uu<MAX_KEY_TABLE; uu++) {
MACvDisableKeyEntry(pDevice->PortOffset, uu);
}
return ret;
}
if(param->u.wpa_key.key && fcpfkernel) {
memcpy(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len);
}
else {
spin_unlock_irq(&pDevice->lock);
if (param->u.wpa_key.key &&
copy_from_user(&abyKey[0], param->u.wpa_key.key, param->u.wpa_key.key_len)) {
spin_lock_irq(&pDevice->lock);
return -EINVAL;
}
spin_lock_irq(&pDevice->lock);
}
dwKeyIndex = (unsigned long)(param->u.wpa_key.key_index);
if (param->u.wpa_key.alg_name == WPA_ALG_WEP) {
if (dwKeyIndex > 3) {
return -EINVAL;
}
else {
if (param->u.wpa_key.set_tx) {
pDevice->byKeyIndex = (unsigned char)dwKeyIndex;
pDevice->bTransmitKey = true;
dwKeyIndex |= (1 << 31);
}
KeybSetDefaultKey(&(pDevice->sKey),
dwKeyIndex & ~(BIT30 | USE_KEYRSC),
param->u.wpa_key.key_len,
NULL,
abyKey,
KEY_CTL_WEP,
pDevice->PortOffset,
pDevice->byLocalID);
}
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
pDevice->bEncryptionEnable = true;
return ret;
}
if(param->u.wpa_key.seq && fcpfkernel) {
memcpy(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len);
}
else {
spin_unlock_irq(&pDevice->lock);
if (param->u.wpa_key.seq &&
copy_from_user(&abySeq[0], param->u.wpa_key.seq, param->u.wpa_key.seq_len)) {
spin_lock_irq(&pDevice->lock);
return -EINVAL;
}
spin_lock_irq(&pDevice->lock);
}
if (param->u.wpa_key.seq_len > 0) {
for (ii = 0 ; ii < param->u.wpa_key.seq_len ; ii++) {
if (ii < 4)
LODWORD(KeyRSC) |= (abySeq[ii] << (ii * 8));
else
HIDWORD(KeyRSC) |= (abySeq[ii] << ((ii-4) * 8));
}
dwKeyIndex |= 1 << 29;
}
if (param->u.wpa_key.key_index >= MAX_GROUP_KEY) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return dwKeyIndex > 3\n");
return -EINVAL;
}
if (param->u.wpa_key.alg_name == WPA_ALG_TKIP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
}
if (param->u.wpa_key.alg_name == WPA_ALG_CCMP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
}
if (param->u.wpa_key.set_tx)
dwKeyIndex |= (1 << 31);
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)
byKeyDecMode = KEY_CTL_CCMP;
else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled)
byKeyDecMode = KEY_CTL_TKIP;
else
byKeyDecMode = KEY_CTL_WEP;
if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
if (param->u.wpa_key.key_len == MAX_KEY_LEN)
byKeyDecMode = KEY_CTL_TKIP;
else if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
} else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
if (param->u.wpa_key.key_len == WLAN_WEP40_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
else if (param->u.wpa_key.key_len == WLAN_WEP104_KEYLEN)
byKeyDecMode = KEY_CTL_WEP;
}
if ((byKeyDecMode == KEY_CTL_TKIP) &&
(param->u.wpa_key.key_len != MAX_KEY_LEN)) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return- TKIP Key must be 256 bits!\n");
return -EINVAL;
}
if ((byKeyDecMode == KEY_CTL_CCMP) &&
(param->u.wpa_key.key_len != AES_KEY_LEN)) {
return -EINVAL;
}
if (is_broadcast_ether_addr(¶m->addr[0]) || (param->addr == NULL)) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Groupe Key Assign.\n");
if ((KeybSetAllGroupKey(&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(unsigned char *)abyKey,
byKeyDecMode,
pDevice->PortOffset,
pDevice->byLocalID) == true) &&
(KeybSetDefaultKey(&(pDevice->sKey),
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(unsigned char *)abyKey,
byKeyDecMode,
pDevice->PortOffset,
pDevice->byLocalID) == true) ) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "GROUP Key Assign.\n");
} else {
return -EINVAL;
}
} else {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Assign.\n");
if (byKeyDecMode == KEY_CTL_WEP) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key can't be WEP\n");
return -EINVAL;
}
dwKeyIndex |= (1 << 30);
if (pMgmt->eConfigMode == WMAC_CONFIG_IBSS_STA) {
return -EINVAL;
}
if (KeybSetKey(&(pDevice->sKey),
¶m->addr[0],
dwKeyIndex,
param->u.wpa_key.key_len,
(PQWORD) &(KeyRSC),
(unsigned char *)abyKey,
byKeyDecMode,
pDevice->PortOffset,
pDevice->byLocalID) == true) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pairwise Key Set\n");
} else {
if (!compare_ether_addr(¶m->addr[0], pDevice->abyBSSID)) {
return -EINVAL;
} else {
return -EINVAL;
}
}
}
if ((ret == 0) && ((param->u.wpa_key.set_tx) != 0)) {
pDevice->byKeyIndex = (unsigned char)param->u.wpa_key.key_index;
pDevice->bTransmitKey = true;
}
pDevice->bEncryptionEnable = true;
return ret;
}
acpi_status
acpi_ev_gpe_initialize (void)
{
u32 i;
u32 j;
u32 register_index;
u32 gpe_number;
u16 gpe0register_count;
u16 gpe1_register_count;
FUNCTION_TRACE ("Ev_gpe_initialize");
/*
* Set up various GPE counts
*
* You may ask,why are the GPE register block lengths divided by 2?
* From the ACPI 2.0 Spec, section, 4.7.1.6 General-Purpose Event
* Registers, we have,
*
* "Each register block contains two registers of equal length
* GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the
* GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN
* The length of the GPE1_STS and GPE1_EN registers is equal to
* half the GPE1_LEN. If a generic register block is not supported
* then its respective block pointer and block length values in the
* FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need
* to be the same size."
*/
gpe0register_count = (u16) DIV_2 (acpi_gbl_FADT->gpe0blk_len);
gpe1_register_count = (u16) DIV_2 (acpi_gbl_FADT->gpe1_blk_len);
acpi_gbl_gpe_register_count = gpe0register_count + gpe1_register_count;
if (!acpi_gbl_gpe_register_count) {
REPORT_WARNING (("Zero GPEs are defined in the FADT\n"));
return_ACPI_STATUS (AE_OK);
}
/*
* Allocate the Gpe information block
*/
acpi_gbl_gpe_registers = ACPI_MEM_CALLOCATE (acpi_gbl_gpe_register_count *
sizeof (acpi_gpe_registers));
if (!acpi_gbl_gpe_registers) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Could not allocate the Gpe_registers block\n"));
return_ACPI_STATUS (AE_NO_MEMORY);
}
/*
* Allocate the Gpe dispatch handler block
* There are eight distinct GP events per register.
* Initialization to zeros is sufficient
*/
acpi_gbl_gpe_info = ACPI_MEM_CALLOCATE (MUL_8 (acpi_gbl_gpe_register_count) *
sizeof (acpi_gpe_level_info));
if (!acpi_gbl_gpe_info) {
ACPI_MEM_FREE (acpi_gbl_gpe_registers);
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not allocate the Gpe_info block\n"));
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Set the Gpe validation table to GPE_INVALID */
MEMSET (acpi_gbl_gpe_valid, (int) ACPI_GPE_INVALID, ACPI_NUM_GPE);
/*
* Initialize the Gpe information and validation blocks. A goal of these
* blocks is to hide the fact that there are two separate GPE register sets
* In a given block, the status registers occupy the first half, and
* the enable registers occupy the second half.
*/
/* GPE Block 0 */
register_index = 0;
for (i = 0; i < gpe0register_count; i++) {
acpi_gbl_gpe_registers[register_index].status_addr =
(u16) (ACPI_GET_ADDRESS (acpi_gbl_FADT->Xgpe0blk.address) + i);
acpi_gbl_gpe_registers[register_index].enable_addr =
(u16) (ACPI_GET_ADDRESS (acpi_gbl_FADT->Xgpe0blk.address) + i + gpe0register_count);
acpi_gbl_gpe_registers[register_index].gpe_base = (u8) MUL_8 (i);
for (j = 0; j < 8; j++) {
gpe_number = acpi_gbl_gpe_registers[register_index].gpe_base + j;
acpi_gbl_gpe_valid[gpe_number] = (u8) register_index;
}
/*
* Clear the status/enable registers. Note that status registers
* are cleared by writing a '1', while enable registers are cleared
* by writing a '0'.
*/
acpi_os_write_port (acpi_gbl_gpe_registers[register_index].enable_addr, 0x00, 8);
acpi_os_write_port (acpi_gbl_gpe_registers[register_index].status_addr, 0xFF, 8);
register_index++;
}
/* GPE Block 1 */
for (i = 0; i < gpe1_register_count; i++) {
acpi_gbl_gpe_registers[register_index].status_addr =
(u16) (ACPI_GET_ADDRESS (acpi_gbl_FADT->Xgpe1_blk.address) + i);
acpi_gbl_gpe_registers[register_index].enable_addr =
(u16) (ACPI_GET_ADDRESS (acpi_gbl_FADT->Xgpe1_blk.address) + i + gpe1_register_count);
acpi_gbl_gpe_registers[register_index].gpe_base =
(u8) (acpi_gbl_FADT->gpe1_base + MUL_8 (i));
for (j = 0; j < 8; j++) {
gpe_number = acpi_gbl_gpe_registers[register_index].gpe_base + j;
acpi_gbl_gpe_valid[gpe_number] = (u8) register_index;
}
/*
* Clear the status/enable registers. Note that status registers
* are cleared by writing a '1', while enable registers are cleared
* by writing a '0'.
*/
acpi_os_write_port (acpi_gbl_gpe_registers[register_index].enable_addr, 0x00, 8);
acpi_os_write_port (acpi_gbl_gpe_registers[register_index].status_addr, 0xFF, 8);
register_index++;
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "GPE registers: %X@%8.8X%8.8X (Blk0) %X@%8.8X%8.8X (Blk1)\n",
gpe0register_count, HIDWORD(acpi_gbl_FADT->Xgpe0blk.address), LODWORD(acpi_gbl_FADT->Xgpe0blk.address),
gpe1_register_count, HIDWORD(acpi_gbl_FADT->Xgpe1_blk.address), LODWORD(acpi_gbl_FADT->Xgpe1_blk.address)));
return_ACPI_STATUS (AE_OK);
}
