BOOL CNdasEventMonitor::Initialize() { // // Initialize routine is reentrant one. // // // Auto-reset waitable timer // if (INVALID_HANDLE_VALUE == m_hHeartbeatMonitorTimer) { m_hHeartbeatMonitorTimer = ::CreateWaitableTimer(NULL, FALSE, NULL); } if (INVALID_HANDLE_VALUE == m_hHeartbeatMonitorTimer) { DBGPRT_ERR_EX(_FT("Timer creation failed: ")); return FALSE; } if (NULL == m_hLogDeviceSetChangeEvent) { m_hLogDeviceSetChangeEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); } if (NULL == m_hLogDeviceSetChangeEvent) { DBGPRT_ERR_EX(_FT("Logical device set change event creation failed: ")); return FALSE; } return CTask::Initialize(); }
BOOL CNdasEventPublisher::AcceptNewConnection() { CLIENT_DATA* pClientData = NULL; pClientData = new CLIENT_DATA; ::ZeroMemory(pClientData, sizeof(CLIENT_DATA)); if (NULL == pClientData) { DBGPRT_ERR_EX(_FT("Out of memory: ")); return FALSE; } pClientData->overlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); if (NULL == pClientData->overlapped.hEvent) { // Unable to create an event DBGPRT_ERR_EX(_FT("Creating an event failed: ")); delete pClientData; return FALSE; } pClientData->hPipe = CreatePipeInstance(&pClientData->overlapped); if (INVALID_HANDLE_VALUE == pClientData->hPipe) { // Unable to create a pipe instance DBGPRT_ERR_EX(_FT("Creating the pipe instance failed: ")); ::CloseHandle(pClientData->overlapped.hEvent); pClientData->overlapped.hEvent = NULL; delete pClientData; return FALSE; } m_PipeData.push_back(pClientData); return TRUE; }
DWORD CNdasIXServer::OnTaskStart() { DBGPRT_INFO(_FT("Starting NdasIXServer.\n")); CLpxDatagramServer m_dgs; BOOL fSuccess = m_dgs.Initialize(); if (!fSuccess) { DBGPRT_ERR_EX(_FT("CNdasIXServer init failed: ")); return 255; } fSuccess = m_dgs.Receive( this, m_usListenPort, INFOX_MAX_DATAGRAM_PKT_SIZE, m_hTaskTerminateEvent); if (!fSuccess) { DBGPRT_ERR_EX(_FT("Listening IXServer at port %d failed: "), m_usListenPort); return 255; } return 0; }
BOOL CLpxStreamListener::GetAcceptResult( OUT SOCKADDR_LPX* lpLocalAddr, OUT SOCKADDR_LPX* lpRemoteAddr, OUT LPDWORD lpcbReceived, OUT CONST BYTE** ppbData, OUT LPDWORD lpdwFlags /* = NULL */) { BOOL fSuccess = ::WSAGetOverlappedResult( m_sock, &m_ovReceive, lpcbReceived, TRUE, lpdwFlags); if (!fSuccess) { DBGPRT_ERR_EX(_FT("WSAGetOverlappedResult failed: ")); return FALSE; } *ppbData = (CONST BYTE*) m_wsaReceiveBuffer.buf; SOCKADDR_LPX *pLocalAddr, *pRemoteAddr; INT iLocalAddrLen, iRemoteAddrLen; LPFN_GETACCEPTEXSOCKADDRS lpfnAcceptExSockaddrs = NULL; GUID GuidAcceptExSockaddrs = WSAID_GETACCEPTEXSOCKADDRS; DWORD cbRead; INT iResult = ::WSAIoctl(m_sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &GuidAcceptExSockaddrs, sizeof(GuidAcceptExSockaddrs), &lpfnAcceptExSockaddrs, sizeof(lpfnAcceptExSockaddrs), &cbRead, NULL, NULL); if (NULL == lpfnAcceptExSockaddrs) { DBGPRT_ERR_EX(_FT("Cannot load AcceptEx function: ")); return FALSE; } lpfnAcceptExSockaddrs( m_wsaReceiveBuffer.buf, m_wsaReceiveBuffer.len, sizeof(SOCKADDR_LPX) + 16, sizeof(SOCKADDR_LPX) + 16, (sockaddr**) &pLocalAddr, &iLocalAddrLen, (sockaddr**) &pRemoteAddr, &iRemoteAddrLen); *lpLocalAddr = *pLocalAddr; *lpRemoteAddr = *pRemoteAddr; return TRUE; }
BOOL WINAPI NdasDmGetVolumeNumberOfDriveLetter(int drvno, ULONG *vol) { BOOL bret = FALSE ; HANDLE volMgr ; TCHAR volName[] = _T("\\\\.\\A:") ; VOLUME_NUMBER VN ; ULONG retsz ; // // fix volume name // volName[4] += (TCHAR)drvno ; DBGPRT_INFO(_FT("DOS device name: %s\n"), volName); // // open the volume manager // volMgr = CreateFile(volName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL) ; if(volMgr == INVALID_HANDLE_VALUE) { DBGPRT_ERR_EX(_FT("CreateFile(%s) failed: "), volName); return FALSE ; } bret = DeviceIoControl( volMgr, IOCTL_VOLUME_QUERY_VOLUME_NUMBER, NULL, // lpInBuffer 0, // size of input buffer (LPVOID) &VN, // output buffer (DWORD) sizeof(VN), // size of output buffer &retsz, // number of bytes returned NULL // OVERLAPPED structure ) ; if(bret == FALSE) { DBGPRT_ERR_EX(_FT("DeviceIoControl(IOCTL_VOLUME_QUERY_VOLUME_NUMBER) failed: ")); goto cleanup ; } DBGPRT_INFO(_FT("Volume Number:%d\n"), VN.VolumeNumber ); DBGPRT_INFO(_FT("Volume Manager Name:%ws\n"), VN.VolumeManagerName ); *vol = VN.VolumeNumber ; cleanup: if(volMgr != 0 && volMgr != INVALID_HANDLE_VALUE) CloseHandle(volMgr) ; return bret ; }
BOOL CLpxStreamConnection::Connect( CONST SOCKADDR_LPX* pRemoteAddr, CONST BYTE* lpSendBuffer, DWORD dwSendDataLen, LPDWORD lpcbSent) { _ASSERTE(INVALID_SOCKET != m_sock); ResetSendOverlapped(); LPFN_CONNECTEX lpfnConnectEx = NULL; GUID GuidConnectEx = WSAID_CONNECTEX; DWORD cbRead; INT iResult = ::WSAIoctl(m_sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &GuidConnectEx, sizeof(GuidConnectEx), &lpfnConnectEx, sizeof(lpfnConnectEx), &cbRead, NULL, NULL); if (NULL == lpfnConnectEx) { DBGPRT_ERR_EX(_FT("Cannot load ConnectEx function: ")); return FALSE; } BOOL fSuccess = lpfnConnectEx( m_sock, (const sockaddr*) pRemoteAddr, sizeof(SOCKADDR_LPX), (PVOID) lpSendBuffer, dwSendDataLen, lpcbSent, &m_ovSend); if (fSuccess) { fSuccess = ::SetEvent(m_hSentEvent); _ASSERTE(fSuccess); return TRUE; } if (ERROR_IO_PENDING != ::WSAGetLastError()) { DBGPRT_ERR_EX(_FT("ConnectEx at sock %p failed: "), m_sock); return FALSE; } return TRUE; }
BOOL GetLocalLpxAddressList( IN SOCKET s, IN DWORD cbBuffer, OUT LPSOCKET_ADDRESS_LIST lpBuffer, OUT LPDWORD pcbBytesReturned) { _ASSERTE(INVALID_SOCKET != s); _ASSERTE(!IsBadWritePtr(lpBuffer, cbBuffer)); INT iError = WSAIoctl( s, SIO_ADDRESS_LIST_QUERY, NULL, 0, lpBuffer, cbBuffer, pcbBytesReturned, NULL, NULL); if (iError != 0) { DBGPRT_ERR_EX(_FT("SIO_ADDRESS_LIST_QUERY failed: ")); return FALSE; } return TRUE; }
BOOL CLpxAsyncSocket::_GetRecvResult( OUT LPDWORD lpcbReceived, OUT BYTE** ppbData, OUT LPDWORD lpdwFlags /* = NULL */) { DWORD cbReceived = 0; DWORD dwFlags = 0; BOOL fSuccess = ::WSAGetOverlappedResult( m_sock, &m_ovReceive, &cbReceived, TRUE, &dwFlags); if (!fSuccess) { DBGPRT_ERR_EX(_FT("WSAGetOverlappedResult failed: ")); return FALSE; } *ppbData = (BYTE*)m_wsaReceiveBuffer.buf; if (lpcbReceived) *lpcbReceived = cbReceived; if (lpdwFlags) *lpdwFlags = dwFlags; return TRUE; }
BOOL CLpxAsyncSocket::AllocRecvBuf(DWORD cbSize) { if (cbSize > m_wsaReceiveBuffer.len) { if (NULL != m_wsaReceiveBuffer.buf) { m_wsaReceiveBuffer.buf = (char*) ::HeapReAlloc( ::GetProcessHeap(), HEAP_ZERO_MEMORY, m_wsaReceiveBuffer.buf, cbSize); } else { m_wsaReceiveBuffer.buf = (char*) ::HeapAlloc( ::GetProcessHeap(), HEAP_ZERO_MEMORY, cbSize); } if (NULL == m_wsaReceiveBuffer.buf) { DBGPRT_ERR_EX(_FT("Allocating RecvBuf %d bytes failed: "), cbSize); m_wsaReceiveBuffer.len = 0; return FALSE; } m_wsaReceiveBuffer.len = cbSize; } return TRUE; }
BOOL CNdasLogicalDevice::Unplug() { BOOL fSuccess(FALSE); ximeta::CAutoLock autolock(this); DBGPRT_INFO(_FT("Unplugging %s\n"), ToString()); if (m_status == NDAS_LOGICALDEVICE_STATUS_NOT_INITIALIZED) { ::SetLastError(NDASHLPSVC_ERROR_NDAS_LOGICALDEVICE_NOT_INITIALIZED); return FALSE; } if (m_status != NDAS_LOGICALDEVICE_STATUS_MOUNTED && m_status != NDAS_LOGICALDEVICE_STATUS_MOUNT_PENDING && m_status != NDAS_LOGICALDEVICE_STATUS_UNMOUNT_PENDING) { ::SetLastError(NDASHLPSVC_ERROR_NDAS_LOGICALDEVICE_NOT_MOUNTED); return FALSE; } // // Remove target ejects the disk and the volume. // fSuccess = LsBusCtlRemoveTarget(m_NdasScsiLocation.SlotNo); if (!fSuccess) { DBGPRT_WARN_EX(_FT("LsBusCtlRemoveTarget failed: ")); } // Intentional break ::Sleep(100); // // BUG: // What happened when RemoveTarget succeeded and // Unplugging LANSCSI port is failed? // fSuccess = LsBusCtlUnplug(m_NdasScsiLocation.SlotNo); if (!fSuccess) { DBGPRT_ERR_EX(_FT("LsBusCtlUnplug failed: ")); // last error from lsbusctl unplug return FALSE; } // // Change the status to unmounted // SetStatus(NDAS_LOGICALDEVICE_STATUS_UNMOUNTED); DBGPRT_INFO(_FT("Unplugged successfully at slot %s.\n"), CNdasScsiLocation(m_NdasScsiLocation).ToString()); return TRUE; }
BOOL CNdasEventPublisher::SendVersionInfo(HANDLE hPipe, LPOVERLAPPED lpOverlapped) { const DWORD cbMessage = sizeof(NDAS_EVENT_MESSAGE); NDAS_EVENT_MESSAGE msgVersion = {0}; msgVersion.MessageSize = cbMessage; msgVersion.EventType = NDAS_EVENT_TYPE_VERSION_INFO; msgVersion.VersionInfo.MajorVersion = NDAS_EVENT_VERSION_MAJOR; msgVersion.VersionInfo.MinorVersion = NDAS_EVENT_VERSION_MINOR; DWORD cbWritten(0); BOOL fSuccess = ::WriteFile( hPipe, &msgVersion, cbMessage, &cbWritten, lpOverlapped); if (!fSuccess && ERROR_IO_PENDING != ::GetLastError()) { DBGPRT_ERR_EX(_FT("Writing an initial version event failed: ")); return FALSE; } return TRUE; }
BOOL WINAPI NdasDmGetScsiPortNumberOfDisk( IN DWORD dwPhysicalDiskNumber, OUT LPDWORD lpdwScsiPortNumber) { _ASSERTE(!IsBadWritePtr(lpdwScsiPortNumber, sizeof(DWORD))); // // make up Physical Drive Name // TCHAR szDiskDevicePath[_MAX_PATH + 1]; HRESULT hr = ::StringCchPrintf( szDiskDevicePath, _MAX_PATH + 1, _T("\\\\.\\PHYSICALDRIVE%d"), dwPhysicalDiskNumber); _ASSERT(SUCCEEDED(hr)); DBGPRT_INFO(_FT("Disk Device Path:%s\n"), szDiskDevicePath); // // open the disk device // DBGPRT_TRACE(_FT("CreateFile(%s)\n"), szDiskDevicePath); HANDLE hDisk = ::CreateFile( szDiskDevicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (INVALID_HANDLE_VALUE == hDisk) { DBGPRT_ERR_EX(_FT("CreateFile(%s) failed: "), szDiskDevicePath); return FALSE; } // // Get SCSI Port Number of the Disk // BOOL fSuccess = NdasDmGetScsiPortNumberOfDisk(hDisk, lpdwScsiPortNumber); if (!fSuccess) { DBGPRT_ERR(_FT("NdasDmGetScsiPortNumberOfDisk(%s) failed.\n"), szDiskDevicePath); (VOID) ::CloseHandle(hDisk); return FALSE; } (VOID) ::CloseHandle(hDisk); return TRUE; }
BOOL CNdasLogicalDevice::Initialize() { ximeta::CAutoLock autolock(this); if (NDAS_LOGICALDEVICE_STATUS_NOT_INITIALIZED != m_status) { // Already initialized return TRUE; } if (NULL == m_hDisconnectedEvent) { m_hDisconnectedEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); if (NULL == m_hDisconnectedEvent) { DBGPRT_ERR_EX(_FT("Disconnect event creation failed: ")); return FALSE; } } if (NULL == m_hAlarmEvent) { m_hAlarmEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); if (NULL == m_hAlarmEvent) { DBGPRT_ERR_EX(_FT("Alarm event creation failed: ")); ::CloseHandle(m_hDisconnectedEvent); return FALSE; } } ACCESS_MASK lastMountAccess = GetLastMountAccess(); BOOL fRiskyMountFlag = GetRiskyMountFlag(); if (fRiskyMountFlag) { m_fRiskyMount = fRiskyMountFlag; } if ((lastMountAccess > 0) && !IsRiskyMount()) { SetMountOnReady(lastMountAccess, FALSE); } SetStatus(NDAS_LOGICALDEVICE_STATUS_UNMOUNTED); DBGPRT_INFO(_FT("Logical Device %d initialized successfully.\n"), m_logicalDeviceId); return TRUE; }
BOOL CNdasDevice::InvalidateUnitDevice(DWORD dwUnitNo) { ximeta::CAutoLock autoLock(this); DBGPRT_INFO(_FT("%s: Invalidating Unit Device %d\n"), ToString(), dwUnitNo); if (dwUnitNo >= MAX_NDAS_UNITDEVICE_COUNT) { DBGPRT_INFO(_T("%s: Invalid Unit No: %d\n"), ToString(), dwUnitNo); ::SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } if (NDAS_DEVICE_STATUS_CONNECTED != GetStatus()) { DBGPRT_INFO(_T("%s: Non-connected device ignored\n"), ToString()); return FALSE; } BOOL fSuccess = UpdateDeviceInfo(); if (!fSuccess) { DBGPRT_ERR_EX(_T("%s: Device is not available.\n"), ToString()); return FALSE; } fSuccess = DestroyUnitDevice(dwUnitNo); if (!fSuccess) { DBGPRT_ERR_EX(_FT("%s: Destroying unit device (%d) failed: "), ToString(), dwUnitNo); return FALSE; } fSuccess = CreateUnitDevice(dwUnitNo); if (!fSuccess) { DBGPRT_ERR_EX(_FT("%s: Creating unit device (%d) failed: "), ToString(), dwUnitNo); return FALSE; } DBGPRT_INFO(_FT("%s: Unit Device (%d) recreated\n"), ToString(), dwUnitNo); return TRUE; }
BOOL CNdasDeviceHeartbeatListener::Initialize() { BOOL fSuccess = m_dgramServer.Initialize(); if (!fSuccess) { DBGPRT_ERR_EX(_FT("CLpxDatagramServer init failed: ")); return FALSE; } return CTask::Initialize(); }
BOOL CLpxAsyncSocket::ShutDown(INT nHow) { _ASSERTE(INVALID_SOCKET != m_sock); INT iResult = ::shutdown(m_sock, nHow); if (0 != iResult) { DBGPRT_ERR_EX(_FT("Shutting down a sock %p failed: "), m_sock); return FALSE; } return TRUE; }
BOOL CNdasLogicalDevice::GetSharedWriteInfo( LPBOOL lpbSharedWrite, LPBOOL lpbPrimary) { if (lpbSharedWrite) { #ifdef NDAS_FEATURE_DISABLE_SHARED_WRITE *lpbSharedWrite = FALSE; #else *lpbSharedWrite = TRUE; #endif } #ifdef NDAS_FEATURE_DISABLE_SHARED_WRITE // none for no shared write software #else if (NULL == lpbPrimary) { return TRUE; } BUSENUM_QUERY_INFORMATION BusEnumQuery = {0}; BUSENUM_INFORMATION BusEnumInformation = {0}; BusEnumQuery.InfoClass = INFORMATION_PDO; BusEnumQuery.Size = sizeof(BUSENUM_QUERY_INFORMATION); BusEnumQuery.SlotNo = m_NdasScsiLocation.SlotNo; BOOL fSuccess = ::LsBusCtlQueryInformation( &BusEnumQuery, sizeof(BUSENUM_QUERY_INFORMATION), &BusEnumInformation, sizeof(BUSENUM_INFORMATION)); if (!fSuccess) { DBGPRT_ERR_EX(_FT("LanscsiQueryInformation failed at slot %d: "), m_NdasScsiLocation.SlotNo); return FALSE; } if (ND_ACCESS_ISRW(BusEnumInformation.PdoInfo.GrantedAccess)) { *lpbPrimary = TRUE; } else { *lpbPrimary = FALSE; } #endif return TRUE; }
BOOL CLpxStreamListener::Listen(INT nBacklog /* = SOMAXCONN */) { _ASSERTE(INVALID_SOCKET != m_sock); INT iResult = ::listen(m_sock, nBacklog); if (0 != iResult) { DBGPRT_ERR_EX(_FT("listen on %p failed: "), m_sock); return FALSE; } return TRUE; }
BOOL CLpxSockAddrListChangeNotifier::Reset() { BOOL fSuccess = ::ResetEvent(m_hEvent); _ASSERT(fSuccess); if (INVALID_SOCKET != m_sock) { ::closesocket(m_sock); } // ::ZeroMemory(&m_overlapped, sizeof(WSAOVERLAPPED)); m_overlapped.Internal = m_overlapped.InternalHigh = m_overlapped.Offset = m_overlapped.OffsetHigh = 0; m_overlapped.hEvent = m_hEvent; AutoSocket sock = ::WSASocket( AF_LPX, SOCK_DGRAM, LPXPROTO_DGRAM, NULL, 0, WSA_FLAG_OVERLAPPED); if (INVALID_SOCKET == (SOCKET) sock) { return FALSE; } int iError; DWORD cbBytesReturned; iError = ::WSAIoctl( sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &cbBytesReturned, &m_overlapped, NULL); if (0 != iError && WSA_IO_PENDING != ::WSAGetLastError()) { // SOCKET_ERROR // TODO: Error Event Log from WSAGetLastError DBGPRT_ERR_EX(_FT("WSAIoctl SIO_ADDRESS_LIST_CHANGE failed: ")); return FALSE; } m_sock = sock.Detach(); return TRUE; }
BOOL CLpxSockAddrListChangeNotifier::Initialize() { if (NULL == m_hEvent) { m_hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL); if (NULL == m_hEvent) { DBGPRT_ERR_EX(_FT("Creating a event failed: ")); return FALSE; } } return TRUE; }
BOOL CLpxDatagramSocket::GetSendToResult(LPDWORD lpcbSent) { BOOL fSuccess = CLpxAsyncSocket::_GetSendResult(lpcbSent); if (!fSuccess) { DBGPRT_ERR_EX(_FT("_GetSendResult failed: ")); return FALSE; } UnlockSendQueue(); return TRUE; }
BOOL CLpxDatagramSocket::SendToSync( CONST SOCKADDR_LPX* pRemoteAddr, DWORD cbToSend, CONST BYTE* lpbData, DWORD dwSendFlags, LPDWORD lpcbSent) { BOOL fSuccess = SendTo(pRemoteAddr, cbToSend, lpbData, dwSendFlags); if (!fSuccess) { DBGPRT_ERR_EX(_FT("Send failed: ")); return FALSE; } fSuccess = GetSendToResult(lpcbSent); if (!fSuccess) { DBGPRT_ERR_EX(_FT("GetSendToResult failed: ")); return FALSE; } return TRUE; }
BOOL CLpxStreamConnection::Recv(DWORD cbBufferMax, LPDWORD lpdwFlags) { _ASSERTE(INVALID_SOCKET != m_sock); BOOL fSuccess = FALSE; DWORD cbReceived = 0; fSuccess = AllocRecvBuf(cbBufferMax); if (!fSuccess) { DBGPRT_ERR_EX(_FT("AllocRecvBuf failed: ")); return FALSE; } ResetRecvOverlapped(); INT iResult = ::WSARecv( m_sock, &m_wsaReceiveBuffer, 1, &cbReceived, lpdwFlags, &m_ovReceive, NULL); if (0 != iResult && WSA_IO_PENDING != ::WSAGetLastError()) { DBGPRT_ERR_EX(_FT("Recv at sock %p up to %d bytes failed: "), m_sock, cbBufferMax); return FALSE; } if (0 == iResult) { fSuccess = ::SetEvent(m_hReceivedEvent); _ASSERTE(fSuccess); return TRUE; } return TRUE; }
BOOL CNdasDeviceComm::GetUnitDeviceInformation(PNDAS_UNITDEVICE_HARDWARE_INFO pUnitDevInfo) { XTLASSERT(NULL != m_hNdas && "CNdasDeviceComm is not connected"); XTLASSERT(pUnitDevInfo != NULL); BOOL fSuccess = NdasCommGetUnitDeviceHardwareInfo(m_hNdas, pUnitDevInfo); if (!fSuccess) { DBGPRT_ERR_EX(_FT("NdasCommGetUnitDeviceInfo failed: ")); return FALSE; } return TRUE; }
// #if WINVER >= 0x0501 BOOL CLpxStreamConnection::Disconnect(DWORD dwFlags) { _ASSERTE(INVALID_SOCKET != m_sock); LPFN_DISCONNECTEX lpfnDisconnectEx = NULL; GUID GuidDisconnectEx = WSAID_CONNECTEX; DWORD cbRead; INT iResult = ::WSAIoctl(m_sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &GuidDisconnectEx, sizeof(GuidDisconnectEx), &lpfnDisconnectEx, sizeof(lpfnDisconnectEx), &cbRead, NULL, NULL); if (NULL == lpfnDisconnectEx) { DBGPRT_ERR_EX(_FT("Cannot load DisconnectEx function: ")); return FALSE; } BOOL fSuccess = lpfnDisconnectEx( m_sock, NULL, dwFlags, 0); if (!fSuccess) { DBGPRT_ERR_EX(_FT("DisconnectEx failed: ")); return FALSE; } return TRUE; }
BOOL CNdasUnitDeviceCreator::ReadDIBv1AndConvert(PNDAS_DIB_V2 pDIBv2) { BOOL fSuccess = FALSE; NDAS_DIB DIBv1 = {0}; PNDAS_DIB pDIBv1 = &DIBv1; fSuccess = m_devComm.ReadDiskBlock( reinterpret_cast<PBYTE>(pDIBv1), NDAS_BLOCK_LOCATION_DIB_V1); if (!fSuccess) { DBGPRT_ERR_EX(_FT("Reading DIBv1 block failed: ")); return FALSE; } // // If there is no DIB in the disk, // create a pseudo DIBv2 // if (NDAS_DIB_SIGNATURE != pDIBv1->Signature || IS_NDAS_DIBV1_WRONG_VERSION(*pDIBv1)) { // // Create a pseudo DIBv2 // InitializeDIBv2AsSingle(pDIBv2); return TRUE; } // // Convert V1 to V2 // fSuccess = ConvertDIBv1toDIBv2( pDIBv1, pDIBv2, m_udinfo.SectorCount.QuadPart); if (!fSuccess) { // // Create a pseudo DIBv2 again! // InitializeDIBv2AsSingle(pDIBv2); return TRUE; } return TRUE; }
BOOL CNdasUnitDeviceCreator::ReadContentEncryptBlock( PNDAS_CONTENT_ENCRYPT_BLOCK pCEB) { BOOL fSuccess = m_devComm.ReadDiskBlock( reinterpret_cast<PBYTE>(pCEB), NDAS_BLOCK_LOCATION_ENCRYPT); if(!fSuccess) { DBGPRT_ERR_EX(_FT("Unable to read CEB: ")); return FALSE; } return TRUE; }
DWORD CNdasDeviceHeartbeatListener::OnTaskStart() { BOOL fSuccess = m_dgramServer.Receive( this, m_usListenPort, sizeof(NDAS_DEVICE_HEARTBEAT), m_hTaskTerminateEvent); if (!fSuccess) { DBGPRT_ERR_EX(_FT("Listening Heartbeat at port %d failed: "), m_usListenPort); return 255; } return 0; }
BOOL CNdasEventPublisher::AddEvent( const NDAS_EVENT_MESSAGE& eventMessage) { m_queueLock.Lock(); m_EventMessageQueue.push(eventMessage); m_queueLock.Unlock(); BOOL fSuccess = ::ReleaseSemaphore(m_hSemQueue, 1, NULL); if (!fSuccess) { // Queue Full DBGPRT_ERR_EX(_FT("Event Message Queue Full, Discarded %s :"), NdasEventTypeString(eventMessage.EventType)); return FALSE; } DBGPRT_INFO(_FT("Event Message Queued: %s\n"), NdasEventTypeString(eventMessage.EventType)); return TRUE; }
BOOL CNdasDeviceComm::ReadDiskBlock(PBYTE pBlockBuffer, INT64 i64DiskBlock, INT32 i32BlockSize) { XTLASSERT(NULL != m_hNdas && "CNdasDeviceComm is not connected"); XTLASSERT(pBlockBuffer != NULL); XTLASSERT(i32BlockSize >= 1 && i32BlockSize <= 128); XTLASSERT(!::IsBadWritePtr(pBlockBuffer, i32BlockSize * 512)); BOOL fSuccess = NdasCommBlockDeviceRead( m_hNdas, i64DiskBlock, i32BlockSize, pBlockBuffer); if (!fSuccess) { DBGPRT_ERR_EX(_FT("NdasCommBlockDeviceRead failed: ")); return FALSE; } return TRUE; }