BOOL
WINAPI
NdasDmGetNdasLogDevSlotNoOfDisk(HANDLE hDisk, LPDWORD lpdwSlotNo)
{
_ASSERTE(INVALID_HANDLE_VALUE != hDisk);
_ASSERTE(NULL != hDisk);
_ASSERTE(!IsBadWritePtr(lpdwSlotNo, sizeof(DWORD)));
BOOL fSuccess(FALSE);
DWORD dwScsiPortNumber;
fSuccess = NdasDmGetScsiPortNumberOfDisk(hDisk, &dwScsiPortNumber);
if (!fSuccess) {
DPError(_FT("NdasDmGetScsiPortNumberOfDisk(%p) failed.\n"),
hDisk);
return FALSE;
}
fSuccess = NdasDmGetNdasLogDevSlotNoOfScsiPort(dwScsiPortNumber, lpdwSlotNo);
if (!fSuccess) {
DPError(_FT("NdasDmGetNdasLogDevSlotNoOfScsiPort(%d) failed.\n"),
dwScsiPortNumber);
return FALSE;
}
return TRUE;
}
static BOOL GetFileVerInfoString(LPCTSTR szFilePath, LPCTSTR szSubBlock, CString& szData)
{
DWORD dwHandle, dwSize;
BOOL fSuccess(FALSE);
dwSize = ::GetFileVersionInfoSize(szFilePath, &dwHandle);
if (0 == dwSize)
return FALSE;
LPVOID lpData = new BYTE[dwSize];
if (NULL == lpData)
return FALSE;
fSuccess = ::GetFileVersionInfo(szFilePath, dwHandle, dwSize, lpData);
if (!fSuccess)
return FALSE;
LPVOID lpValue;
UINT uiValueLen;
fSuccess = ::VerQueryValue(lpData, (LPTSTR)szSubBlock, &lpValue, &uiValueLen);
if (!fSuccess)
return FALSE;
szData = (LPCTSTR) lpValue;
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;
}
int __cdecl _tmain(int argc, LPTSTR* argv)
{
BOOL fSuccess(FALSE);
BOOL bret;
if(argc < 2) {
usage();
return 1;
}
if (lstrcmpi(argv[1],TEXT("version")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
WORD NdfsMajor;
WORD NdfsMinor;
bret = XixfsCtlGetVersion(
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate,
&NdfsMajor,
&NdfsMinor
);
if(bret == FALSE) {
_tprintf(TEXT("Xixfs control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- Xixfs version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n")
TEXT("NDFS Maj: %u\n")
TEXT("NDFS Min: %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate,
NdfsMajor, NdfsMinor);
}
} else if (lstrcmpi(argv[1],TEXT("unload")) == 0) {
bret = XixfsCtlReadyForUnload();
if(bret == FALSE) {
_tprintf(TEXT("Xixfs control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- Xixfs is ready to unload\n"));
}
} else {
usage();
}
return fSuccess ? 0 : 1;
}
BOOL
CRegistryCfg::SetSecureValueEx(
LPCTSTR szContainer, LPCTSTR szValueName,
LPCVOID lpValue, DWORD cbValue)
{
DATA_BLOB DataIn;
DataIn.cbData = cbValue;
DataIn.pbData = (LPBYTE) lpValue;
DATA_BLOB DataOut; // to call LocalFree to free pbData after use
DataOut.cbData = 0;
DataOut.pbData = NULL;
BOOL fSuccess(FALSE);
static const WCHAR DESCRIPTION[] = L"";
// for Windows 2000, DESCRIPTION field cannot null
// so we are using zero character here.
fSuccess = ::CryptProtectData(
&DataIn,
DESCRIPTION,
(m_Entropy.cbData > 0) ? &m_Entropy : NULL,
NULL,
NULL,
CRYPTPROTECT_LOCAL_MACHINE | CRYPTPROTECT_UI_FORBIDDEN,
&DataOut);
if (!fSuccess) {
return FALSE;
}
// FROM HERE: call LocalFree(DataOut.pbData) when returning
fSuccess = SetRegValueEx(
m_hCfgRootKey,
szContainer,
szValueName,
REG_BINARY,
DataOut.pbData,
DataOut.cbData);
if (!fSuccess) {
::LocalFree(DataOut.pbData);
return FALSE;
}
::LocalFree(DataOut.pbData);
return TRUE;
}
int __cdecl _tmain(int argc, LPTSTR* argv)
{
BOOL fSuccess(FALSE);
ULONG SlotNo;
BOOL bret;
if(argc < 2) {
usage();
return 1;
}
if (lstrcmpi(argv[1],TEXT("version")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
bret = NdasBusCtlGetVersion(
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate
);
if(bret == FALSE) {
_tprintf(TEXT("LanscsiBus control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- LanscsiBus version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate);
}
#if 0
} else if(lstrcmpi(argv[1],TEXT("mpversion")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = NdasBusCtlGetMiniportVersion(
SlotNo,
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate
);
if(bret == FALSE) {
_tprintf(TEXT("NDASSCSI control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- NDASSCSI version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate);
}
#endif
} else if(lstrcmpi(argv[1],TEXT("slotlist")) == 0) {
PNDASBUS_INFORMATION busInfo;
bret = NdasBusCtlQueryPdoSlotList(&busInfo);
if(bret == FALSE) {
_tprintf(TEXT("Querying slot list failed. LastError:%lu\n"), GetLastError());
} else {
ULONG idx_slot;
_tprintf(TEXT("Slot list:"));
for(idx_slot = 0; idx_slot < busInfo->PdoSlotList.SlotNoCnt; idx_slot++ ) {
_tprintf(TEXT(" %lu"), busInfo->PdoSlotList.SlotNo[idx_slot]);
}
_tprintf(TEXT("\n"));
HeapFree(GetProcessHeap(), 0, busInfo);
}
} else if(lstrcmpi(argv[1],TEXT("pdoinfo")) == 0) {
NDASBUS_QUERY_INFORMATION BusEnumQuery = {0};
NDASBUS_INFORMATION BusEnumInformation = {0};
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
//
// Get default priamry/secondary information from the NDAS bus drver.
//
BusEnumQuery.InfoClass = INFORMATION_PDO;
BusEnumQuery.Size = sizeof(NDASBUS_QUERY_INFORMATION);
BusEnumQuery.SlotNo = SlotNo;
BusEnumQuery.Flags = 0;
bret = NdasBusCtlQueryInformation(
&BusEnumQuery,
sizeof(NDASBUS_QUERY_INFORMATION),
&BusEnumInformation,
sizeof(NDASBUS_INFORMATION));
if(bret == FALSE) {
_tprintf(TEXT("NdasBusCtlQueryInformation failed. LASTERR=%x\n"), GetLastError());
return 1;
}
_tprintf(TEXT("Ndas logical address: %d\n"), SlotNo);
_tprintf(TEXT("Adapter status : %08lx\n"), BusEnumInformation.PdoInfo.AdapterStatus);
_tprintf(TEXT("Device mode : %08lx\n"), BusEnumInformation.PdoInfo.DeviceMode);
_tprintf(TEXT("Supported features: %08lx\n"), BusEnumInformation.PdoInfo.SupportedFeatures);
_tprintf(TEXT("Enabled features : %08lx\n"), BusEnumInformation.PdoInfo.EnabledFeatures);
} else if(lstrcmpi(argv[1],TEXT("pdoevent")) == 0) {
ULONG ulStatus;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = NdasBusCtlQueryEvent(SlotNo, &ulStatus);
if(bret == FALSE) {
DWORD lastError = GetLastError();
if(lastError == ERROR_NO_MORE_ITEMS) {
_tprintf(TEXT("No more event exists.\n"));
} else if(lastError == ERROR_FILE_NOT_FOUND) {
_tprintf(TEXT("No PDO exists.\n"));
} else {
_tprintf(TEXT("Querying PDO event failed. LastError:%lu\n"), GetLastError());
}
} else {
PrintStatus(ulStatus);
}
} else if(lstrcmpi(argv[1],TEXT("pdoeventptr")) == 0) {
HANDLE alarm;
HANDLE discon;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = NdasBusCtlQueryPdoEvent(SlotNo, &alarm, &discon);
if(bret == FALSE) {
_tprintf(TEXT("Querying pdo events failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf( TEXT("Alarm event : %p\n")
TEXT("Disconnection event: %p\n"),
alarm, discon
);
bret = CloseHandle(alarm);
if(bret == FALSE) {
_tprintf(TEXT("Closing alarm event failed. LastError:%lu\n"), GetLastError());
}
bret = CloseHandle(discon);
if(bret == FALSE) {
_tprintf(TEXT("Closing disconnection event failed. LastError:%lu\n"), GetLastError());
}
}
} else if(lstrcmpi(argv[1],TEXT("status")) == 0) {
ULONG ulStatus;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = NdasBusCtlQueryStatus(SlotNo, &ulStatus);
if(bret == FALSE) {
_tprintf(TEXT("Querying PDO status failed. LastError:%lu\n"), GetLastError());
} else {
PrintStatus(ulStatus);
}
} else if(lstrcmpi(argv[1],TEXT("fdoinfo")) == 0) {
PNDSCIOCTL_LURINFO lurFullInfo;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = NdasBusCtlQueryMiniportFullInformation(SlotNo, &lurFullInfo);
if(bret == FALSE) {
_tprintf(TEXT("Querying LUR full information failed. LastError:%lu\n"), GetLastError());
} else {
ULONG idx_ud;
PNDSC_LURN_FULL unitDisk;
_tprintf(TEXT("Structure length :%u\n"), lurFullInfo->Length);
_tprintf(TEXT("Lur.Length :%u\n"), lurFullInfo->Lur.Length);
_tprintf(TEXT("Lur.DevType :%08lx\n"), lurFullInfo->Lur.DevType);
_tprintf(TEXT("Lur.TargetId :%u\n"), lurFullInfo->Lur.TargetId);
_tprintf(TEXT("Lur.Lun :%u\n"), lurFullInfo->Lur.Lun);
_tprintf(TEXT("Lur.DeviceMode :%08lx\n"), lurFullInfo->Lur.DeviceMode);
_tprintf(TEXT("Lur.SupportedFeatures :%08lx\n"), lurFullInfo->Lur.SupportedFeatures);
_tprintf(TEXT("Lur.EnabledFeatures :%08lx\n"), lurFullInfo->Lur.EnabledFeatures);
_tprintf(TEXT("Lur.LurnCnt :%u\n"), lurFullInfo->Lur.LurnCnt);
_tprintf(TEXT("EnableTime :%I64u\n"), lurFullInfo->EnabledTime.QuadPart);
_tprintf(TEXT("UnitDiskCnt :%u\n"), lurFullInfo->UnitDiskCnt);
for(idx_ud = 0; idx_ud < lurFullInfo->UnitDiskCnt; idx_ud++) {
unitDisk = lurFullInfo->UnitDisks + idx_ud;
_tprintf(TEXT("- LURN #%u :\n"), idx_ud);
_tprintf(TEXT("Length :%u\n"), unitDisk->Length);
_tprintf(TEXT("LurnId :%u\n"), unitDisk->LurnId);
_tprintf(TEXT("LurnType :%u\n"), unitDisk->LurnType);
_tprintf(TEXT("NetDiskAddress.TAAddressCount :%u\n"), unitDisk->NetDiskAddress.TAAddressCount);
_tprintf(TEXT("NetDiskAddress.Address[0].AddressType :%x\n"), unitDisk->NetDiskAddress.Address[0].AddressType);
_tprintf(TEXT("NetDiskAddress.Address[0].AddressLength :%x\n"), unitDisk->NetDiskAddress.Address[0].AddressLength);
_tprintf(TEXT("NetDiskAddress.Address[0].Address :%02X %02X | %02X %02X %02X %02X %02X %02X\n"),
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[0],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[1],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[2],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[3],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[4],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[5],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[6],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[7]
);
_tprintf(TEXT("BindingAddress.TAAddressCount :%u\n"), unitDisk->BindingAddress.TAAddressCount);
_tprintf(TEXT("BindingAddress.Address[0].AddressType :%x\n"), unitDisk->BindingAddress.Address[0].AddressType);
_tprintf(TEXT("BindingAddress.Address[0].AddressLength :%x\n"), unitDisk->BindingAddress.Address[0].AddressLength);
_tprintf(TEXT("BindingAddress.Address[0].Address :%02X %02X | %02X %02X %02X %02X %02X %02X\n"),
(int)unitDisk->BindingAddress.Address[0].Address.Address[0],
(int)unitDisk->BindingAddress.Address[0].Address.Address[1],
(int)unitDisk->BindingAddress.Address[0].Address.Address[2],
(int)unitDisk->BindingAddress.Address[0].Address.Address[3],
(int)unitDisk->BindingAddress.Address[0].Address.Address[4],
(int)unitDisk->BindingAddress.Address[0].Address.Address[5],
(int)unitDisk->BindingAddress.Address[0].Address.Address[6],
(int)unitDisk->BindingAddress.Address[0].Address.Address[7]
);
_tprintf(TEXT("UnitDiskId :%u\n"), (int)unitDisk->UnitDiskId);
_tprintf(TEXT("UserID :%02x %02x %02x %02x\n"),
(int)unitDisk->UserID[0],
(int)unitDisk->UserID[1],
(int)unitDisk->UserID[2],
(int)unitDisk->UserID[3]
);
_tprintf(TEXT("Password :%02x %02x %02x %02x %02x %02x\n"),
(int)unitDisk->Password[0],
(int)unitDisk->Password[1],
(int)unitDisk->Password[2],
(int)unitDisk->Password[3],
(int)unitDisk->Password[4],
(int)unitDisk->Password[5]
);
_tprintf(TEXT("AccessRight :%08lx\n"), unitDisk->AccessRight);
_tprintf(TEXT("UnitBlocks :%u\n"), unitDisk->UnitBlocks);
_tprintf(TEXT("StatusFlags :%u\n"), unitDisk->StatusFlags);
}
_tprintf(TEXT("\n"));
HeapFree(GetProcessHeap(), 0, lurFullInfo);
}
} else if(lstrcmpi(argv[1],TEXT("pdofile")) == 0) {
HANDLE pdoFileHandle;
SlotNo = _tstoi(argv[2]);
bret = NdasBusCtlQueryPdoFileHandle(SlotNo, &pdoFileHandle);
if(bret == FALSE) {
_tprintf(TEXT("Querying PDO file handle failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("PDO file handle :%p\n"), pdoFileHandle);
CloseHandle(pdoFileHandle);
}
} else {
usage();
}
return fSuccess ? 0 : 1;
}
BOOL
WINAPI
NdasDmGetNdasLogDevSlotNoOfScsiPort(
HANDLE hScsiPort,
LPDWORD lpdwSlotNo)
{
//
// Make up IOCTL In-parameter
// LANSCSIMINIPORT_IOCTL_GET_SLOT_NO to get Logical Device Slot No
//
BOOL fSuccess(FALSE);
const DWORD cbHeader = sizeof(SRB_IO_CONTROL);
const DWORD cbData = sizeof(ULONG);
const DWORD cbInBuffer = cbHeader + cbData;
DWORD cbReturned(0);
BYTE lpInBuffer[cbInBuffer];
::ZeroMemory(lpInBuffer, cbInBuffer);
PSRB_IO_CONTROL pSrbIoControl = (PSRB_IO_CONTROL) lpInBuffer;
pSrbIoControl->HeaderLength = cbHeader;
::CopyMemory(pSrbIoControl->Signature, LANSCSIMINIPORT_IOCTL_SIGNATURE, 8);
pSrbIoControl->Timeout = 10;
pSrbIoControl->ControlCode = LANSCSIMINIPORT_IOCTL_GET_SLOT_NO;
pSrbIoControl->Length = cbData;
//
// Get Logical Device Slot No
//
fSuccess = ::DeviceIoControl(
hScsiPort,
IOCTL_SCSI_MINIPORT,
lpInBuffer,
cbInBuffer,
lpInBuffer, // we use the same buffer for output
cbInBuffer,
&cbReturned,
NULL);
if (!fSuccess) {
DPErrorEx(_FT("DeviceIoControl(IOCTL_SCSI_MINIPORT,")
_T("LANSCSIMINIPORT_IOCTL_GET_SLOT_NO) failed: "));
return FALSE;
}
if (0 != pSrbIoControl->ReturnCode) {
DPError(_FT("DeviceIoControl(IOCTL_SCSI_MINIPORT,")
_T("LANSCSIMINIPORT_IOCTL_GET_SLOT_NO) returned SrbIoControl error %d.\n"),
pSrbIoControl->ReturnCode);
::SetLastError(NDASDM_ERROR_SRB_IO_CONTROL_ERROR);
return FALSE;
}
//
// Calculate the slot number offset and retrieve the value
//
ULONG* lpdwSlotNoOut = (ULONG*)(lpInBuffer + cbHeader);
*lpdwSlotNo = *lpdwSlotNoOut;
DPInfo(_FT("NDAS Logical Device Slot: %d\n"), *lpdwSlotNo);
return TRUE;
}
BOOL
WINAPI
NdasDmGetDriveNumberOfVolume(
HANDLE hVolume,
LPDWORD lpdwFirstDriverLetter)
{
_ASSERTE(INVALID_HANDLE_VALUE != hVolume);
_ASSERTE(NULL != hVolume);
_ASSERTE(!IsBadWritePtr(lpdwFirstDriverLetter, sizeof(DWORD)));
BOOL fSuccess(FALSE);
VOLUME_NUMBER volumeNumber ;
//
// find a volume number for hFile
//
DWORD cbReturned;
fSuccess = ::DeviceIoControl(
hVolume,
IOCTL_VOLUME_QUERY_VOLUME_NUMBER,
NULL,
0,
(LPVOID) &volumeNumber,
(DWORD) sizeof(VOLUME_NUMBER),
&cbReturned,
NULL);
if (!fSuccess) {
DPErrorEx(_FT("DeviceIoControl(IOCTL_VOLUME_QUERY_VOLUME_NUMBER) failed: "));
return FALSE;
}
DPInfo(_FT("Volume Number: %d\n"), volumeNumber.VolumeNumber);
// VolumeManagerName is 8 wide-chars without null
DPInfo(_FT("Volume Manager Name: %c%c%c%c%c%c%c%c\n"),
(TCHAR)volumeNumber.VolumeManagerName[0], (TCHAR)volumeNumber.VolumeManagerName[1],
(TCHAR)volumeNumber.VolumeManagerName[2], (TCHAR)volumeNumber.VolumeManagerName[3],
(TCHAR)volumeNumber.VolumeManagerName[4], (TCHAR)volumeNumber.VolumeManagerName[5],
(TCHAR)volumeNumber.VolumeManagerName[6], (TCHAR)volumeNumber.VolumeManagerName[7]);
DWORD dwLogicalDriveSet = ::GetLogicalDrives() ;
if(dwLogicalDriveSet == 0) {
DPErrorEx(_FT("GetLogicalDrivers() failed: "));
return FALSE ;
}
//
// go through every drive letter from 1 (to skip drive A:)
//
for(DWORD i = 1 ; i < 26 ; ++i) {
if( (dwLogicalDriveSet & ( 1 << i )) == 0 )
continue ;
ULONG vn;
fSuccess = NdasDmGetVolumeNumberOfDriveLetter(i, &vn) ;
if(!fSuccess)
continue ;
if(volumeNumber.VolumeNumber == vn) {
*lpdwFirstDriverLetter = i ;
return TRUE ;
}
}
return FALSE ;
}
BOOL
WINAPI
NdasDmGetNdasLogDevSlotNoOfVolume(
HANDLE hVolume,
LPDWORD lpdwSlotNo,
DWORD nBuffer,
LPDWORD lpdwBufferUsed)
{
_ASSERTE(INVALID_HANDLE_VALUE != hVolume);
_ASSERTE(NULL != hVolume);
_ASSERTE(!IsBadWritePtr(lpdwSlotNo, sizeof(DWORD) * nBuffer));
_ASSERTE(!IsBadWritePtr(lpdwBufferUsed, sizeof(DWORD)));
BOOL fSuccess(FALSE);
//
// Get the physical disk numbers of the volume
//
DWORD pDiskNumbers[256];
DWORD nDiskNumbers;
fSuccess = NdasDmGetDiskNumbersOfVolume(hVolume, pDiskNumbers, 256, &nDiskNumbers);
if (!fSuccess) {
DPError(_FT("NdasDmGetDiskNumbersOfVolume failed.\n"));
return FALSE;
}
//
// Get SCSI port number for each disks
//
// TODO: Resolve this problem!
// What if the volume is spanned through NDAS Logical Disks and
// OS's regular Disks?
//
*lpdwBufferUsed = 0;
for (DWORD i = 0; i < nDiskNumbers; ++i) {
if (*lpdwBufferUsed >= nBuffer) {
DPError(_FT("Insufficient Slot Buffer.\n"));
::SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
DWORD dwDiskNumber = pDiskNumbers[i];
DWORD dwScsiPortNumber;
fSuccess = NdasDmGetScsiPortNumberOfDisk(dwDiskNumber, &dwScsiPortNumber);
if (!fSuccess) {
DPErrorEx(_FT("NdasDmGetScsiPortNumberOfDisk(%d) failed: "), dwDiskNumber);
return FALSE;
}
DWORD dwSlotNo;
fSuccess = NdasDmGetNdasLogDevSlotNoOfScsiPort(dwScsiPortNumber, &dwSlotNo);
if (!fSuccess) {
DPErrorEx(_FT("NdasDmGetNdasLogDevSlotNoOfScsiPort(%d) failed: "), dwScsiPortNumber);
return FALSE;
}
BOOL bDuplicate(FALSE);
for (DWORD j = 0; j < *lpdwBufferUsed; ++j) {
if (lpdwSlotNo[j] == dwSlotNo) {
bDuplicate = TRUE;
break;
}
}
if (!bDuplicate) {
lpdwSlotNo[*lpdwBufferUsed] = dwSlotNo;
(*lpdwBufferUsed)++;
}
}
return TRUE;
}
BOOL CNamedPipeTransport::Send(
LPCVOID lpBuffer, DWORD cbToSend, LPDWORD lpcbSent,
LPOVERLAPPED lpOverlapped, DWORD dwFlags)
{
// AUTOFUNCTRACE();
_ASSERTE(!IsBadReadPtr(lpBuffer, cbToSend));
_ASSERTE(!IsBadWritePtr(lpcbSent, sizeof(DWORD)));
_ASSERTE(
(NULL == lpOverlapped) ||
(!IsBadReadPtr(lpOverlapped, sizeof(OVERLAPPED)) &&
NULL != lpOverlapped->hEvent &&
INVALID_HANDLE_VALUE != lpOverlapped->hEvent));
UNREFERENCED_PARAMETER(dwFlags);
// handling sending zero-byte packet
if (cbToSend == 0) {
*lpcbSent = 0;
if (lpOverlapped) {
BOOL fSuccess = ::SetEvent(lpOverlapped->hEvent);
_ASSERT(fSuccess);
}
DPInfo(_FT("Sending 0 byte ignored\n"));
return TRUE;
}
DPInfo(_FT("Sending %d bytes.\n"), cbToSend);
BOOL fSuccess(FALSE);
DWORD cbCurSent(0), cbCurToSend(cbToSend);
const BYTE* lpCurBuffer = reinterpret_cast<const BYTE*>(lpBuffer);
*lpcbSent = 0;
while (cbCurToSend > 0) {
fSuccess = ::WriteFile(m_hPipe, lpBuffer, cbCurToSend, &cbCurSent, lpOverlapped);
if (!fSuccess && NULL != lpOverlapped && ::GetLastError() != ERROR_IO_PENDING) {
break;
}
if (lpOverlapped) {
// wait until timeout (to prevent indefinite waiting...)
DWORD dwWaitResult = ::WaitForSingleObject(lpOverlapped->hEvent, TRANSMIT_TIMEOUT);
if (dwWaitResult != WAIT_OBJECT_0) {
switch (dwWaitResult) {
case WAIT_TIMEOUT: ::SetLastError(WAIT_TIMEOUT);
case WAIT_ABANDONED: ::SetLastError(WAIT_ABANDONED);
default: break;
}
return FALSE;
}
fSuccess = ::GetOverlappedResult(m_hPipe, lpOverlapped, &cbCurSent, TRUE);
if (!fSuccess && ::GetLastError() != ERROR_IO_PENDING) {
break;
}
}
cbCurToSend -= cbCurSent;
*lpcbSent += cbCurSent;
lpCurBuffer += cbCurSent;
}
DPInfo(_FT("Sent %d bytes.\n"), *lpcbSent);
return fSuccess;
}
BOOL
WINAPI
NdasDmGetNdasLogDevSlotNoOfScsiPort(
DWORD dwScsiPortNumber,
LPDWORD lpdwSlotNo)
{
BOOL fSuccess(FALSE);
//
// Make up SCSI Port Name
//
TCHAR szScsiPortName[_MAX_PATH + 1];
HRESULT hr = ::StringCchPrintf(
szScsiPortName, _MAX_PATH + 1,
TEXT("\\\\.\\Scsi%d:"), dwScsiPortNumber);
DPInfo(_FT("SCSI Port Name: %s\n"), szScsiPortName);
//
// Open SCSI Port Device
//
HANDLE hScsiPort = ::CreateFile(
szScsiPortName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == hScsiPort) {
DPErrorEx(_FT("CreateFile(%s) failed: "), szScsiPortName);
return FALSE;
}
//
// Make up IOCTL In-parameter
// LANSCSIMINIPORT_IOCTL_GET_SLOT_NO to get Logical Device Slot No
//
const DWORD cbHeader = sizeof(SRB_IO_CONTROL);
const DWORD cbData = sizeof(ULONG);
const DWORD cbInBuffer = cbHeader + cbData;
DWORD cbReturned(0);
BYTE lpInBuffer[cbInBuffer];
::ZeroMemory(lpInBuffer, cbInBuffer);
PSRB_IO_CONTROL pSrbIoControl = (PSRB_IO_CONTROL) lpInBuffer;
pSrbIoControl->HeaderLength = cbHeader;
::CopyMemory(pSrbIoControl->Signature, LANSCSIMINIPORT_IOCTL_SIGNATURE, 8);
pSrbIoControl->Timeout = 10;
pSrbIoControl->ControlCode = LANSCSIMINIPORT_IOCTL_GET_SLOT_NO;
pSrbIoControl->Length = cbData;
//
// Get Logical Device Slot No
//
fSuccess = ::DeviceIoControl(
hScsiPort,
IOCTL_SCSI_MINIPORT,
lpInBuffer,
cbInBuffer,
lpInBuffer, // we use the same buffer for output
cbInBuffer,
&cbReturned,
NULL);
if (!fSuccess) {
DPErrorEx(_FT("DeviceIoControl(IOCTL_SCSI_MINIPORT,")
_T("LANSCSIMINIPORT_IOCTL_GET_SLOT_NO) failed: "));
::CloseHandle(hScsiPort);
return FALSE;
}
if (0 != pSrbIoControl->ReturnCode) {
DPError(_FT("DeviceIoControl(IOCTL_SCSI_MINIPORT,")
_T("LANSCSIMINIPORT_IOCTL_GET_SLOT_NO) returned error %d.\n"),
pSrbIoControl->ReturnCode);
::CloseHandle(hScsiPort);
return FALSE;
}
//
// Calculate the slot number offset and retrieve the value
//
ULONG* lpdwSlotNoOut = (ULONG*)(lpInBuffer + cbHeader);
*lpdwSlotNo = *lpdwSlotNoOut;
DPInfo(_FT("NDAS Logical Device Slot: %d\n"), *lpdwSlotNo);
::CloseHandle(hScsiPort);
return TRUE;
}
int __cdecl _tmain(int argc, LPTSTR* argv)
{
BOOL fSuccess(FALSE);
ULONG SlotNo;
BOOL bret;
if(argc < 2) {
usage();
return 1;
}
if (lstrcmpi(argv[1],TEXT("version")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
bret = LsBusCtlGetVersion(
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate
);
if(bret == FALSE) {
_tprintf(TEXT("LanscsiBus control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- LanscsiBus version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate);
}
} else if(lstrcmpi(argv[1],TEXT("mpversion")) == 0) {
WORD VersionMajor;
WORD VersionMinor;
WORD VersionBuild;
WORD VersionPrivate;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlGetMiniportVersion(
SlotNo,
&VersionMajor,
&VersionMinor,
&VersionBuild,
&VersionPrivate
);
if(bret == FALSE) {
_tprintf(TEXT("NDASSCSI control failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("- NDASSCSI version\n"));
_tprintf( TEXT("Major : %u\n")
TEXT("Minor : %u\n")
TEXT("Build : %u\n")
TEXT("Private : %u\n"),
VersionMajor, VersionMinor, VersionBuild, VersionPrivate);
}
} else if(lstrcmpi(argv[1],TEXT("slotlist")) == 0) {
PBUSENUM_INFORMATION busInfo;
bret = LsBusCtlQueryPdoSlotList(&busInfo);
if(bret == FALSE) {
_tprintf(TEXT("Querying slot list failed. LastError:%lu\n"), GetLastError());
} else {
ULONG idx_slot;
_tprintf(TEXT("Slot list:"));
for(idx_slot = 0; idx_slot < busInfo->PdoSlotList.SlotNoCnt; idx_slot++ ) {
_tprintf(TEXT(" %lu"), busInfo->PdoSlotList.SlotNo[idx_slot]);
}
_tprintf(TEXT("\n"));
HeapFree(GetProcessHeap(), 0, busInfo);
}
} else if(lstrcmpi(argv[1],TEXT("pdoevent")) == 0) {
HANDLE alarm;
HANDLE discon;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryPdoEvent(SlotNo, &alarm, &discon);
if(bret == FALSE) {
_tprintf(TEXT("Querying pdo events failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf( TEXT("Alarm event : %p\n")
TEXT("Disconnection event: %p\n"),
alarm, discon
);
bret = CloseHandle(alarm);
if(bret == FALSE) {
_tprintf(TEXT("Closing alarm event failed. LastError:%lu\n"), GetLastError());
}
bret = CloseHandle(discon);
if(bret == FALSE) {
_tprintf(TEXT("Closing disconnection event failed. LastError:%lu\n"), GetLastError());
}
}
} else if(lstrcmpi(argv[1],TEXT("status")) == 0) {
ULONG ulStatus;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryStatus(SlotNo, &ulStatus);
if(bret == FALSE) {
_tprintf(TEXT("Querying LUR full information failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("ADAPTERINFO_STATUS : %s\n"),
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_INIT) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_INIT") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_RUNNING) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_RUNNING") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPING) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_STOPPING") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_IN_ERROR) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_IN_ERROR") :
ADAPTERINFO_ISSTATUS(ulStatus, NDASSCSI_ADAPTERINFO_STATUS_STOPPED) ? TEXT("NDASSCSI_ADAPTERINFO_STATUS_STOPPED") :
TEXT("Unknown status"));
#define PRINT_FLAG(STATUS, FLAG) \
_tprintf(TEXT("") TEXT(#FLAG) TEXT(": %s\n"), ADAPTERINFO_ISSTATUSFLAG((STATUS), (FLAG)) ? TEXT("ON") : TEXT("off"));
PRINT_FLAG(ulStatus, NDASSCSI_ADAPTERINFO_STATUSFLAG_RECONNECT_PENDING);
PRINT_FLAG(ulStatus, ADAPTERINFO_STATUSFLAG_POWERSAVING_PENDING);
PRINT_FLAG(ulStatus, ADAPTERINFO_STATUSFLAG_BUSRESET_PENDING);
PRINT_FLAG(ulStatus, NDASSCSI_ADAPTERINFO_STATUSFLAG_MEMBER_FAULT);
#undef PRINT_FLAG
}
} else if(lstrcmpi(argv[1],TEXT("fdoinfo")) == 0) {
PNDSCIOCTL_ADAPTERLURINFO lurFullInfo;
if(argc < 3) {
usage();
return 1;
}
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryMiniportFullInformation(SlotNo, &lurFullInfo);
if(bret == FALSE) {
_tprintf(TEXT("Querying LUR full information failed. LastError:%lu\n"), GetLastError());
} else {
ULONG idx_ud;
PNDSC_LURN_FULL unitDisk;
_tprintf(TEXT("Structure length :%u\n"), lurFullInfo->Length);
_tprintf(TEXT("Adapter.SlotNo :%u\n"), lurFullInfo->Adapter.SlotNo);
_tprintf(TEXT("Adapter.Length :%u\n"), lurFullInfo->Adapter.Length);
_tprintf(TEXT("Adapter.InitiatorId :%u\n"), (int)lurFullInfo->Adapter.InitiatorId);
_tprintf(TEXT("Adapter.NumberOfBuses :%u\n"), (int)lurFullInfo->Adapter.NumberOfBuses);
_tprintf(TEXT("Adapter.MaximumNumberOfTargets :%u\n"), (int)lurFullInfo->Adapter.MaximumNumberOfTargets);
_tprintf(TEXT("Adapter.MaximumNumberOfLogicalUnits :%u\n"), (int)lurFullInfo->Adapter.MaximumNumberOfLogicalUnits);
_tprintf(TEXT("Adapter.MaxBlocksPerRequest :%u\n"), lurFullInfo->Adapter.MaxBlocksPerRequest);
_tprintf(TEXT("Adapter.Status :%08lx\n"), lurFullInfo->Adapter.Status);
_tprintf(TEXT("Lur.Length :%u\n"), lurFullInfo->Lur.Length);
_tprintf(TEXT("Lur.DevType :%08lx\n"), lurFullInfo->Lur.DevType);
_tprintf(TEXT("Lur.TargetId :%u\n"), lurFullInfo->Lur.TargetId);
_tprintf(TEXT("Lur.Lun :%u\n"), lurFullInfo->Lur.Lun);
_tprintf(TEXT("Lur.DesiredAccess :%08lx\n"), lurFullInfo->Lur.DesiredAccess);
_tprintf(TEXT("Lur.GrantedAccess :%08lx\n"), lurFullInfo->Lur.GrantedAccess);
_tprintf(TEXT("Lur.LurnCnt :%u\n"), lurFullInfo->Lur.LurnCnt);
_tprintf(TEXT("EnableTime :%I64u\n"), lurFullInfo->EnabledTime.QuadPart);
_tprintf(TEXT("UnitDiskCnt :%u\n"), lurFullInfo->UnitDiskCnt);
for(idx_ud = 0; idx_ud < lurFullInfo->UnitDiskCnt; idx_ud++) {
unitDisk = lurFullInfo->UnitDisks + idx_ud;
_tprintf(TEXT("- LURN #%u :\n"), idx_ud);
_tprintf(TEXT("Length :%u\n"), unitDisk->Length);
_tprintf(TEXT("LurnId :%u\n"), unitDisk->LurnId);
_tprintf(TEXT("LurnType :%u\n"), unitDisk->LurnType);
_tprintf(TEXT("NetDiskAddress.TAAddressCount :%u\n"), unitDisk->NetDiskAddress.TAAddressCount);
_tprintf(TEXT("NetDiskAddress.Address[0].AddressType :%x\n"), unitDisk->NetDiskAddress.Address[0].AddressType);
_tprintf(TEXT("NetDiskAddress.Address[0].AddressLength :%x\n"), unitDisk->NetDiskAddress.Address[0].AddressLength);
_tprintf(TEXT("NetDiskAddress.Address[0].Address :%02X %02X | %02X %02X %02X %02X %02X %02X\n"),
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[0],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[1],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[2],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[3],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[4],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[5],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[6],
(int)unitDisk->NetDiskAddress.Address[0].Address.Address[7]
);
_tprintf(TEXT("BindingAddress.TAAddressCount :%u\n"), unitDisk->BindingAddress.TAAddressCount);
_tprintf(TEXT("BindingAddress.Address[0].AddressType :%x\n"), unitDisk->BindingAddress.Address[0].AddressType);
_tprintf(TEXT("BindingAddress.Address[0].AddressLength :%x\n"), unitDisk->BindingAddress.Address[0].AddressLength);
_tprintf(TEXT("BindingAddress.Address[0].Address :%02X %02X | %02X %02X %02X %02X %02X %02X\n"),
(int)unitDisk->BindingAddress.Address[0].Address.Address[0],
(int)unitDisk->BindingAddress.Address[0].Address.Address[1],
(int)unitDisk->BindingAddress.Address[0].Address.Address[2],
(int)unitDisk->BindingAddress.Address[0].Address.Address[3],
(int)unitDisk->BindingAddress.Address[0].Address.Address[4],
(int)unitDisk->BindingAddress.Address[0].Address.Address[5],
(int)unitDisk->BindingAddress.Address[0].Address.Address[6],
(int)unitDisk->BindingAddress.Address[0].Address.Address[7]
);
_tprintf(TEXT("UnitDiskId :%u\n"), (int)unitDisk->UnitDiskId);
_tprintf(TEXT("UserID :%02x %02x %02x %02x\n"),
(int)unitDisk->UserID[0],
(int)unitDisk->UserID[1],
(int)unitDisk->UserID[2],
(int)unitDisk->UserID[3]
);
_tprintf(TEXT("Password :%02x %02x %02x %02x %02x %02x\n"),
(int)unitDisk->Password[0],
(int)unitDisk->Password[1],
(int)unitDisk->Password[2],
(int)unitDisk->Password[3],
(int)unitDisk->Password[4],
(int)unitDisk->Password[5]
);
_tprintf(TEXT("AccessRight :%08lx\n"), unitDisk->AccessRight);
_tprintf(TEXT("UnitBlocks :%u\n"), unitDisk->UnitBlocks);
_tprintf(TEXT("StatusFlags :%u\n"), unitDisk->StatusFlags);
}
_tprintf(TEXT("\n"));
HeapFree(GetProcessHeap(), 0, lurFullInfo);
}
} else if(lstrcmpi(argv[1],TEXT("pdofile")) == 0) {
HANDLE pdoFileHandle;
SlotNo = _tstoi(argv[2]);
bret = LsBusCtlQueryPdoFileHandle(SlotNo, &pdoFileHandle);
if(bret == FALSE) {
_tprintf(TEXT("Querying PDO file handle failed. LastError:%lu\n"), GetLastError());
} else {
_tprintf(TEXT("PDO file handle :%p\n"), pdoFileHandle);
ZwClose(pdoFileHandle);
}
} else {
usage();
}
return fSuccess ? 0 : 1;
}
BOOL
CNdasLogicalDevice::Recover()
{
BOOL fSuccess(FALSE);
ximeta::CAutoLock autolock(this);
DBGPRT_INFO(_FT("Recovering %s\n"), ToString());
switch(GetType())
{
case NDAS_LOGICALDEVICE_TYPE_DISK_RAID1:
case NDAS_LOGICALDEVICE_TYPE_DISK_RAID4:
break;
default:
return FALSE;
}
if (m_status == NDAS_LOGICALDEVICE_STATUS_NOT_INITIALIZED) {
::SetLastError(NDASHLPSVC_ERROR_NDAS_LOGICALDEVICE_NOT_INITIALIZED);
return FALSE;
}
if (m_status != NDAS_LOGICALDEVICE_STATUS_MOUNTED)
{
::SetLastError(NDASHLPSVC_ERROR_NDAS_LOGICALDEVICE_NOT_MOUNTED);
return FALSE;
}
// Do not recover if any NDAS unit device is not alive
DWORD ldSequence = 0;
for(ldSequence = 0; ldSequence < m_logicalDeviceGroup.nUnitDevices; ldSequence++)
{
if(NDAS_UNITDEVICE_STATUS_MOUNTED != m_pUnitDevices[ldSequence]->GetStatus())
{
::SetLastError(NDASHLPSVC_ERROR_NDAS_UNITDEVICE_NOT_MOUNTED);
return FALSE;
}
}
if(IsAnyUnitDevicesFault())
{
::SetLastError(NDASHLPSVC_ERROR_NDAS_UNITDEVICE_NOT_MOUNTED);
return FALSE;
}
ULONG ulStatus;
fSuccess = ::LsBusCtlQueryStatus(
m_NdasScsiLocation.SlotNo,
&ulStatus);
if (!fSuccess) {
DBGPRT_ERR_EX(_FT("Unable to get status"));
return FALSE;
}
// Do not recover if NDAS logical device is not under emergency
// Do not recover if NDAS logical device is already recovering
if(!ADAPTERINFO_ISSTATUSFLAG(ulStatus, ADAPTERINFO_STATUSFLAG_MEMBER_FAULT))
{
DBGPRT_ERR_EX(_FT("Not in emergency mode or already recovering"));
return FALSE;
}
//
// LsBusCtl is overhauled only to use SlotNo for RemoveTargetData
//
//
// Remove target ejects the disk and the volume.
//
fSuccess = LsBusCtlRecoverTarget(m_NdasScsiLocation.SlotNo);
if (!fSuccess) {
DBGPRT_WARN_EX(_FT("LsBusCtlRemoveTarget failed: "));
}
DBGPRT_INFO(_FT("Started recovering successfully at slot %s.\n"),
CNdasScsiLocation(m_NdasScsiLocation).ToString());
return TRUE;
}
HMENU
CNdasDeviceMenu::CreateDeviceSubMenu(
ndas::Device* pDevice,
NDSI_DATA* psiData)
{
BOOL fSuccess(FALSE);
CMenuHandle menu;
CMenuItemInfo mii;
CMenuItemInfo sep;
CString strText;
sep.fMask = MIIM_TYPE;
sep.fType = MFT_SEPARATOR;
mii.fMask = MIIM_ID | MIIM_STRING | MIIM_DATA;
mii.dwItemData = (WORD)pDevice->GetSlotNo();
fSuccess = menu.CreateMenu();
ATLASSERT(fSuccess);
NDAS_DEVICE_STATUS status = pDevice->GetStatus();
// Enable or Disable
BOOL fShowDisable = FALSE;
BOOL fShowUnregister = FALSE;
if (NDAS_DEVICE_STATUS_DISABLED == status)
{
psiData->Status = NDSI_DISABLED;
pSetDeviceStatusMenuItem(menu,IDS_DEVMST_DEACTIVATED);
fSuccess = strText.LoadString(IDS_ACTIVATE_DEVICE);
ATLASSERT(fSuccess);
mii.wID = IDR_ENABLE_DEVICE;
mii.dwTypeData = (LPTSTR)(LPCTSTR)strText;
fSuccess = menu.InsertMenuItem(0xFFFF, TRUE, &mii);
ATLASSERT(fSuccess);
fShowUnregister = TRUE;
}
else if (NDAS_DEVICE_STATUS_DISCONNECTED == status)
{
//
// although there is no ERROR status in NDAS device,
// if the last error is set, we will show the indicator
// as error
//
psiData->Status =
(ERROR_SUCCESS == pDevice->GetLastError()) ?
NDSI_DISCONNECTED :
NDSI_ERROR;
pSetDeviceStatusMenuItem(menu, IDS_DEVMST_DISCONNECTED);
fShowDisable = TRUE;
fShowUnregister = TRUE;
}
else if (NDAS_DEVICE_STATUS_UNKNOWN == status)
{
psiData->Status = NDSI_UNKNOWN;
pSetDeviceStatusMenuItem(menu, IDS_DEVMST_UNKNOWN);
fShowDisable = TRUE;
fShowUnregister = TRUE;
}
else if (NDAS_DEVICE_STATUS_CONNECTED == status)
{
psiData->Status = NDSI_CONNECTED;
BOOL fMounted = FALSE;
DWORD nDevices = pDevice->GetUnitDeviceCount();
for (DWORD i = 0; i < nDevices; ++i) {
ndas::UnitDevice* pUnitDevice = pDevice->GetUnitDevice(i);
pUnitDevice->UpdateStatus();
BYTE bReserved;
psiData->nParts = min(i + 1, 2);
AppendUnitDeviceMenuItem(
pUnitDevice,
menu.m_hMenu,
(i < 2) ? &psiData->StatusPart[i] : &bReserved);
// If there is a mounted unit device, DISABLE menu will be disabled.
if (NDAS_UNITDEVICE_STATUS_MOUNTED == pUnitDevice->GetStatus()) {
fMounted = TRUE;
}
pUnitDevice->Release();
}
if (!fMounted)
{
fShowDisable = TRUE;
fShowUnregister = TRUE;
}
}
//
// Unregister Device Menu
//
if (fShowUnregister) {
fSuccess = strText.LoadString(IDS_UNREGISTER_DEVICE);
ATLASSERT(fSuccess);
mii.wID = IDR_UNREGISTER_DEVICE;
mii.dwTypeData = (LPTSTR)(LPCTSTR)strText;
fSuccess = menu.InsertMenuItem(0xFFFF, TRUE, &mii);
ATLASSERT(fSuccess);
fSuccess = menu.InsertMenuItem(0xFFFF, TRUE, &sep);
ATLASSERT(fSuccess);
}
//
// We are not using DISABLE in the menu anymore
//
#if USE_DISABLE_COMMAND_IN_MENU
if (fShowDisable) {
fSuccess = strText.LoadString(IDS_DISABLE_DEVICE);
ATLASSERT(fSuccess);
mii.wID = IDR_DISABLE_DEVICE;
mii.dwTypeData = (LPTSTR)(LPCTSTR)strText;
fSuccess = menu.InsertMenuItem(0xFFFF, TRUE, &mii);
ATLASSERT(fSuccess);
fSuccess = menu.InsertMenuItem(0xFFFF, TRUE, &sep);
ATLASSERT(fSuccess);
}
#endif
fSuccess = strText.LoadString(IDS_SHOW_DEVICE_PROPERTIES);
ATLASSERT(fSuccess);
mii.wID = IDR_SHOW_DEVICE_PROPERTIES;
mii.dwTypeData = (LPTSTR)(LPCTSTR)strText;
fSuccess = menu.InsertMenuItem(0xFFFF, TRUE, &mii);
ATLASSERT(fSuccess);
return menu.m_hMenu;
}
BOOL
WINAPI
NdasDmGetDiskNumbersOfVolume(
HANDLE hVolume,
LPDWORD pDiskNumbers,
DWORD dwDiskNumbers,
LPDWORD lpdwDiskNumbersUsed)
{
BOOL fSuccess(FALSE);
DWORD cbReturned(0);
//
// Prepare Volume Disk Extent Buffer
//
DWORD cbVolumeDiskExtents = sizeof(VOLUME_DISK_EXTENTS) +
MAX_VOL_DISK_EXTS * sizeof(VOLUME_DISK_EXTENTS);
PVOLUME_DISK_EXTENTS pVolumeDiskExtents =
(PVOLUME_DISK_EXTENTS) ::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbVolumeDiskExtents);
if (NULL == pVolumeDiskExtents) {
DPErrorEx(_FT("Memory allication (%d bytes) failed: "), cbVolumeDiskExtents);
return FALSE;
}
//
// Get Volume Disk Extents
//
DPTrace(_FT("DeviceIoControl(IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS)\n"));
fSuccess = ::DeviceIoControl(
hVolume,
IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
NULL,
0,
pVolumeDiskExtents,
cbVolumeDiskExtents,
&cbReturned,
NULL);
if (!fSuccess) {
DPErrorEx(_FT("DeviceIoControl(IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS) failed: "));
::HeapFree(::GetProcessHeap(), 0, pVolumeDiskExtents);
return FALSE;
}
//
// usually it returns one disk device
//
*lpdwDiskNumbersUsed = 0;
for (DWORD i = 0; i < pVolumeDiskExtents->NumberOfDiskExtents; ++i) {
DPInfo(_FT("Extents[%d]:: Disk Number: %d, Starting Offset: %d, Extent Length: %d.\n"),
i,
pVolumeDiskExtents->Extents[i].DiskNumber,
pVolumeDiskExtents->Extents[i].StartingOffset,
pVolumeDiskExtents->Extents[i].ExtentLength);
if (i < dwDiskNumbers) {
pDiskNumbers[i] = pVolumeDiskExtents->Extents[i].DiskNumber;
++(*lpdwDiskNumbersUsed);
}
}
::HeapFree(::GetProcessHeap(), 0, pVolumeDiskExtents);
return TRUE;
}
BOOL
CRegistryCfg::GetSecureValueEx(
LPCTSTR szContainer, LPCTSTR szValueName,
LPVOID lpValue, DWORD cbBuffer, LPDWORD lpcbUsed)
{
BOOL fSuccess(FALSE);
DWORD dwRegValueType;
DWORD cbSecuredData;
fSuccess = GetRegValueEx(
m_hCfgRootKey,
szContainer,
szValueName,
&dwRegValueType,
NULL,
0,
&cbSecuredData);
if (!fSuccess) {
return FALSE;
}
LPBYTE lpbSecuredData = (LPBYTE) ::LocalAlloc(LPTR, cbSecuredData);
if (NULL == lpbSecuredData) {
return FALSE;
}
// FROM HERE: call LocalFree(lpbSecuredData) when returning
fSuccess = GetRegValueEx(
HKEY_LOCAL_MACHINE,
szContainer,
szValueName,
&dwRegValueType,
lpbSecuredData,
cbSecuredData,
&cbSecuredData);
DATA_BLOB DataSecured;
DATA_BLOB DataUnsecured;
DataSecured.cbData = cbSecuredData;
DataSecured.pbData = lpbSecuredData;
fSuccess = ProtectEntropy(FALSE);
if (!fSuccess) {
::LocalFree(lpbSecuredData);
return FALSE;
}
// FROM HERE: call ProtectEntropy(TRUE) when returning
fSuccess = ::CryptUnprotectData(
&DataSecured,
NULL,
(m_Entropy.cbData > 0) ? &m_Entropy : NULL,
NULL,
NULL,
CRYPTPROTECT_UI_FORBIDDEN,
&DataUnsecured);
// FROM HERE: call LocalFree(DataUnsecured.pbData) when returning
if (!fSuccess) {
(VOID) ProtectEntropy(TRUE);
::LocalFree(lpbSecuredData);
return FALSE;
}
if (NULL != lpcbUsed) {
*lpcbUsed = DataUnsecured.cbData;
}
if (cbBuffer < DataUnsecured.cbData) {
::SetLastError(ERROR_MORE_DATA);
::LocalFree(DataUnsecured.pbData);
(VOID) ProtectEntropy(TRUE);
::LocalFree(lpbSecuredData);
return FALSE;
}
if (NULL != lpValue) {
::CopyMemory(lpValue, DataUnsecured.pbData, DataUnsecured.cbData);
}
::LocalFree(DataUnsecured.pbData);
(VOID) ProtectEntropy(TRUE);
::LocalFree(lpbSecuredData);
return TRUE;
}
BOOL
WINAPI
NdasDmGetScsiPortNumberOfDisk(
IN HANDLE hDisk,
OUT LPDWORD lpdwScsiPortNumber)
{
_ASSERTE(!IsBadWritePtr(lpdwScsiPortNumber, sizeof(DWORD)));
BOOL fSuccess(FALSE);
DWORD cbReturned(0);
//
// Query Storage Property
//
STORAGE_PROPERTY_QUERY storPropQuery;
STORAGE_ADAPTER_DESCRIPTOR storAdptDesc;
DWORD cbStorPropQuery = sizeof(STORAGE_PROPERTY_QUERY);
DWORD cbStorAdptDesc = sizeof(STORAGE_ADAPTER_DESCRIPTOR);
DPTrace(_FT("DeviceIoControl(IOCTL_STORAGE_QUERY_PROPERTY)\n"));
::ZeroMemory(&storPropQuery, cbStorPropQuery);
storPropQuery.PropertyId = StorageAdapterProperty;
storPropQuery.QueryType = PropertyStandardQuery;
fSuccess = ::DeviceIoControl(
hDisk,
IOCTL_STORAGE_QUERY_PROPERTY,
&storPropQuery,
cbStorPropQuery,
&storAdptDesc,
cbStorAdptDesc,
&cbReturned,
NULL);
if (!fSuccess) {
DPErrorEx(_FT("DeviceIoControl(IOCTL_STORAGE_QUERY_PROPERTY) failed: "));
return FALSE;
}
//
// Ignore non-SCSI device
//
if (BusTypeScsi != storAdptDesc.BusType) {
DPInfo(_FT("Ignoring non-scsi bus\n"));
::SetLastError(NDASDM_ERROR_NON_SCSI_TYPE_DEVICE);
return FALSE;
}
//
// Query SCSI Address, given that the physical drive is a SCSI device
//
SCSI_ADDRESS scsiAddress;
DWORD cbScsiAddress = sizeof(SCSI_ADDRESS);
DPTrace(_FT("DeviceIoControl(IOCTL_SCSI_GET_ADDRESS)\n"));
fSuccess = ::DeviceIoControl(
hDisk,
IOCTL_SCSI_GET_ADDRESS,
NULL,
0,
&scsiAddress,
cbScsiAddress,
&cbReturned,
NULL);
if (!fSuccess) {
DPErrorEx(_FT("DeviceIoControl(IOCTL_SCSI_GET_ADDRESS) failed: "));
return FALSE;
}
DPInfo(_FT("SCSIAddress: Len: %d, PortNumber: %d, PathId: %d, TargetId: %d, Lun: %d\n"),
(DWORD) scsiAddress.Length,
(DWORD) scsiAddress.PortNumber,
(DWORD) scsiAddress.PathId,
(DWORD) scsiAddress.TargetId,
(DWORD) scsiAddress.Lun);
//
// Return the result
//
*lpdwScsiPortNumber = scsiAddress.PortNumber;
return TRUE;
}
void
CMainFrame::pUpdateMenuItems()
{
BOOL fSuccess(FALSE);
if (!ndas::UpdateDeviceList())
{
// warning device list update failed.
}
if (!ndas::UpdateLogicalDeviceList())
{
// warning logical device list update failed.
}
m_taskbarMenu.ClearItemStringData();
BOOL showText = TRUE;
pGetAppConfigValue(_T("ShowDeviceStatusText"), &showText);
m_taskbarMenu.ShowDeviceStatusText(showText);
CMenuHandle taskBarRootMenu;
taskBarRootMenu.LoadMenu(IDR_TASKBAR);
if (pGetAppConfigBOOL(_T("ShowUnmountAll"), FALSE))
{
ndas::LogicalDeviceConstIterator itr = std::find_if(
m_NdasLogDevices.begin(),
m_NdasLogDevices.end(),
ndas::LogicalDeviceMounted());
if (m_NdasLogDevices.end() != itr)
{
// There is a mounted logical device
taskBarRootMenu.EnableMenuItem(
IDR_UNMOUNT_ALL,
MF_BYCOMMAND | MFS_ENABLED);
}
else
{
// There is no mounted logical device
taskBarRootMenu.EnableMenuItem(
IDR_UNMOUNT_ALL,
MF_BYCOMMAND | MFS_DISABLED);
}
// do not remove menu
}
else
{
// otherwise remove menu
taskBarRootMenu.RemoveMenu(IDR_UNMOUNT_ALL, MF_BYCOMMAND);
}
CMenuHandle taskBarMenu = ::GetSubMenu(taskBarRootMenu,0);
MENUINFO mi = {0};
mi.cbSize = sizeof(MENUINFO);
mi.fMask = MIM_STYLE;
fSuccess = taskBarMenu.GetMenuInfo(&mi);
ATLASSERT(fSuccess);
mi.cbSize = sizeof(MENUINFO);
mi.fMask = MIM_STYLE | MIM_APPLYTOSUBMENUS;
mi.dwStyle |= MNS_NOTIFYBYPOS | MNS_CHECKORBMP;
fSuccess = taskBarMenu.SetMenuInfo(&mi);
ATLASSERT(fSuccess);
if (m_NdasDevices.empty())
{
CMenuItemInfo mii;
CString strMenuText = MAKEINTRESOURCE(IDS_NO_DEVICE);
mii.fMask = MIIM_ID | MIIM_STRING | MIIM_STATE;
mii.dwTypeData = (LPTSTR)((LPCTSTR)strMenuText);
mii.wID = IDR_NDAS_DEVICE_NONE;
mii.fState = MFS_DISABLED | MFS_UNHILITE;
fSuccess = taskBarMenu.InsertMenuItem(0, TRUE, &mii);
ATLASSERT(fSuccess);
}
else
{
std::for_each(
m_NdasDevices.begin(),
m_NdasDevices.end(),
NdasDeviceMenuItemCreator(m_taskbarMenu, taskBarMenu));
}
CMenu existingTaskbarMenu = m_taskbarIcon.m_hMenu;
m_taskbarIcon.m_hMenu = taskBarRootMenu;
}
BOOL CNamedPipeTransport::Receive(
LPVOID lpBuffer, DWORD cbToReceive, LPDWORD lpcbReceived,
LPOVERLAPPED lpOverlapped, LPDWORD lpdwFlags)
{
// AUTOFUNCTRACE();
_ASSERTE(!IsBadWritePtr(lpBuffer, cbToReceive));
_ASSERTE(!IsBadWritePtr(lpcbReceived, sizeof(DWORD)));
_ASSERTE(NULL == lpOverlapped ||
!IsBadWritePtr(lpOverlapped, sizeof(OVERLAPPED)) &&
NULL != lpOverlapped->hEvent &&
INVALID_HANDLE_VALUE != lpOverlapped->hEvent);
UNREFERENCED_PARAMETER(lpdwFlags);
// handling sending zero-byte packet
if (cbToReceive == 0) {
*lpcbReceived = 0;
if (lpOverlapped) {
BOOL fSuccess = ::SetEvent(lpOverlapped->hEvent);
_ASSERT(fSuccess);
}
return TRUE;
}
// we have to receive by the request size
DPInfo(_FT("Reading %d bytes.\n"), cbToReceive);
BOOL fSuccess(FALSE);
DWORD cbCurReceived(0), cbCurToReceive(cbToReceive);
LPBYTE lpCurBuffer = reinterpret_cast<LPBYTE>(lpBuffer);
*lpcbReceived = 0;
while (cbCurToReceive > 0) {
fSuccess = ::ReadFile(m_hPipe, lpBuffer, cbCurToReceive, &cbCurReceived, lpOverlapped);
if (!fSuccess && NULL != lpOverlapped && ::GetLastError() != ERROR_IO_PENDING) {
break;
}
if (lpOverlapped) {
// wait until timeout (to prevent indefinite waiting...)
DWORD dwWaitResult = ::WaitForSingleObject(lpOverlapped->hEvent, TRANSMIT_TIMEOUT);
if (dwWaitResult != WAIT_OBJECT_0) {
switch (dwWaitResult) {
case WAIT_TIMEOUT: ::SetLastError(WAIT_TIMEOUT);
case WAIT_ABANDONED: ::SetLastError(WAIT_ABANDONED);
default: break;
}
return FALSE;
}
fSuccess = ::GetOverlappedResult(m_hPipe, lpOverlapped, &cbCurReceived, TRUE);
if (!fSuccess && ::GetLastError() != ERROR_IO_PENDING) {
break;
}
}
cbCurToReceive -= cbCurReceived;
*lpcbReceived += cbCurReceived;
lpCurBuffer += cbCurReceived;
}
DPInfo(_FT("Read %d bytes.\n"), *lpcbReceived);
return fSuccess;
}
