bool MyGetLogicalDriveStrings(CSysStringVector &driveStrings)
{
driveStrings.Clear();
UINT32 size = GetLogicalDriveStrings(0, NULL);
if (size == 0)
return false;
CSysString buffer;
UINT32 newSize = GetLogicalDriveStrings(size, buffer.GetBuffer(size));
if (newSize == 0)
return false;
if (newSize > size)
return false;
CSysString string;
for (UINT32 i = 0; i < newSize; i++)
{
TCHAR c = buffer[i];
if (c == TEXT('\0'))
{
driveStrings.Add(string);
string.Empty();
}
else
string += c;
}
if (!string.IsEmpty())
return false;
return true;
}
void sloDiskManager::FindAllDrivers()
{
DWORD dwNumBytesForDriveStrings;//实际存储驱动器号的字符串长度
HANDLE hHeap;
LPSTR lp;
CString strLogdrive;
//获得实际存储驱动器号的字符串长度
dwNumBytesForDriveStrings=GetLogicalDriveStrings(0,NULL)*sizeof(TCHAR);
//如果字符串不为空，则表示有正常的驱动器存在
if (dwNumBytesForDriveStrings!=0) {
//分配字符串空间
hHeap=GetProcessHeap();
lp=(LPSTR)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,
dwNumBytesForDriveStrings);
//获得标明所有驱动器的字符串
GetLogicalDriveStrings(HeapSize(hHeap,0,lp),lp);
//将驱动器一个个放到下拉框中
while (*lp!=0) {
//Driver->AddString(lp);
GetDrvSpaceInfo(lp);
lp=_tcschr(lp,0)+1;
}
}
}
static int
sync_win32 (void)
{
DWORD n1, n2;
n1 = GetLogicalDriveStrings (0, NULL);
if (n1 == 0)
return -1;
TCHAR buffer[n1+2]; /* sic */
n2 = GetLogicalDriveStrings (n1, buffer);
if (n2 == 0)
return -1;
TCHAR *p = buffer;
/* The MSDN example code itself assumes that there is always one
* drive in the system. However we will be better than that and not
* make the assumption ...
*/
while (*p) {
HANDLE drive;
DWORD drive_type;
/* Ignore removable drives. */
drive_type = GetDriveType (p);
if (drive_type == DRIVE_FIXED) {
/* To open the volume you have to specify the volume name, not
* the mount point. MSDN documents use of the constant 50
* below.
*/
TCHAR volname[50];
if (!GetVolumeNameForVolumeMountPoint (p, volname, 50))
return -1;
drive = CreateFile (volname, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, 0);
if (drive == INVALID_HANDLE_VALUE)
return -1;
BOOL r;
/* This always fails in Wine:
* http://bugs.winehq.org/show_bug.cgi?id=14915
*/
r = FlushFileBuffers (drive);
CloseHandle (drive);
if (!r)
return -1;
}
/* Skip to next \0 character. */
while (*p++);
}
return 0;
}
/* get the list of root directories on mounted drives */
char * getrootdirs (char * getrootdirs)
{
DWORD dw;
dw = GetLogicalDriveStrings (0, NULL);
// fprintf(stderr, "GetLogicalDriveStrings: %d\n", dw);
getrootdirs = HeapAlloc (GetProcessHeap(), 0, dw * sizeof(TCHAR));
GetLogicalDriveStrings (dw, getrootdirs);
// fprintf(stderr, "getrootdirs: %s\n", getrootdirs);
return(getrootdirs);
}
LONG GetDriveList(drv_list_t& drvList)
{
DWORD dwLen = GetLogicalDriveStrings(0, 0);
TCHAR* tszDriveList = new TCHAR[dwLen + 1];
dwLen = GetLogicalDriveStrings(dwLen, tszDriveList);
LONG lRet = ParseDriveString(drvList, tszDriveList);
delete[] tszDriveList;
return lRet;
}
/*
*******************************************************************
* Function: bool GetLogicalDrives()
*
* Description : Will fill the virtools aray (from the P-In)
* with a list of the logical drives
*
* Paramters :
* CKBehavior* r The virtool behaviour
*
* Returns : True if it succeeds, otherwise false
*
*******************************************************************
*/
bool CGBLFileSystem::GetLogicalDrives(CKBehavior* beh)
{
// scan for a list of all the logical drives "a:\ b:\ c:\"
char *allDriveStrings = NULL;
// get the length of the string to be returned
size_t lAllDriveStrings = GetLogicalDriveStrings( 0, NULL );
// Get the destination data array and clear it out
CKDataArray* dataArray = static_cast<CKDataArray*>(beh->GetInputParameterObject(eParamInputDataArray));
if (!dataArray)
{
CGBLWidget::OutputBBErrorMsg(beh, "Please attatch an array to the BB");
return FALSE;
}
dataArray->Clear();
assert( allDriveStrings == NULL );
// get the string containing all the logical drives
allDriveStrings = new char[ lAllDriveStrings + sizeof (EMPTY_STRING) ]; // + for trailer
if( GetLogicalDriveStrings( lAllDriveStrings, allDriveStrings ) != lAllDriveStrings - 1 )
{
CGBLWidget::OutputBBErrorMsg(beh, "Failed to get logical drive strings");
return FALSE;
}
else
{
assert( allDriveStrings != NULL );
char* driveString = allDriveStrings;
size_t lDriveString = strlen( driveString );
char valueToAdd[BUFSIZE]={'\0'};
// loop through all the logical drives, tyring to get a display name
while( lDriveString > 0 )
{
strcpy(valueToAdd,driveString);
dataArray->AddRow();
int currentRow = dataArray->GetRowCount()-1; // 0 index
dataArray->SetElementStringValue(currentRow,NAME_COLUMN,valueToAdd);
driveString += lDriveString + 1;
lDriveString = strlen( driveString );
}
// cleanup
if (allDriveStrings)
{
delete allDriveStrings;
allDriveStrings = NULL;
}
}
return TRUE;
}
bool IdentClient::SendParaSysStorage()
{
bool bRet = false;
if (m_IsSvrConnected)
{
memset(&m_cmdTransfer,0x00,sizeof(m_cmdTransfer));
size_t szAllDriveStrings = GetLogicalDriveStrings(0,NULL);
char *pDriveStrings = new char[szAllDriveStrings + sizeof((""))];
GetLogicalDriveStrings(szAllDriveStrings,pDriveStrings);
size_t szDriveString = strlen(pDriveStrings);
int iMaxnumDrive = sizeof(g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc)/sizeof(g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[0]);
int DriveIndex = 0;
for(DriveIndex = 0; DriveIndex < iMaxnumDrive && szDriveString > 0; DriveIndex++)
{
strcpy((char *)g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].disk_name,pDriveStrings);
unsigned long long FreeAv,TotalBytes,FreeBytes;
if (GetDiskFreeSpaceEx(pDriveStrings,&FreeAv,&TotalBytes,&FreeBytes))
{
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].realsize = TotalBytes.QuadPart/(unsigned long long)(1024*1024);
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].emptysize = FreeAv.QuadPart/(unsigned long long)(1024*1024);
}
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].drive_type = (DRIVE_TYPE)GetDriveType(pDriveStrings);
char drive_fs_type[128];
if(!GetVolumeInformation(pDriveStrings,NULL,0,NULL,NULL,NULL,drive_fs_type,128))
{
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].drive_fstype = DRIVE_FS_TYPE_UNKNOWN;
}
else
{
if(!strcmp(drive_fs_type,"NTFS"))
{
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].drive_fstype = DRIVE_FS_TYPE_NTFS;
}
else if(!strcmp(drive_fs_type,"FAT32"))
{
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].drive_fstype = DRIVE_FS_TYPE_FAT32;
}
else
{
g_stGlobal_Flash.sysstoragepara.storageconfig.diskdesc[DriveIndex].drive_fstype = DRIVE_FS_TYPE_UNKNOWN;
}
}
pDriveStrings += szDriveString + 1;
szDriveString = strlen(pDriveStrings);
}
g_stGlobal_Flash.sysstoragepara.storageconfig.diskcount = DriveIndex;
bRet = CONSTRUCT_CMD(CMD_NUM_SYS_STORAGE_RESPONSE,(char *)&g_stGlobal_Variable.globalflash.sysstoragepara,sizeof(SYS_STORAGE_PARA),&m_cmdTransfer);
bRet &= SendParaMsg();
}
return bRet;
}
BOOL CDirTreeCtrl::DisplayDrives()
{
//
// Displaying the Availible Drives on this PC
// This are the First Items in the TreeCtrl
//
DeleteAllItems();
char szDrives[128];
char* pDrive;
if ( !GetLogicalDriveStrings( sizeof(szDrives), szDrives ) )
{
m_strError = "Error Getting Logical DriveStrings!";
return FALSE;
}
pDrive = szDrives;
while( *pDrive )
{
if (!m_bFixedOnly || GetDriveType(pDrive) == DRIVE_FIXED)
{
*pDrive = toupper(*pDrive);
HTREEITEM hParent = AddItem( TVI_ROOT, pDrive );
if ( FindSubDir( pDrive ) )
InsertItem( "", 0, 0, hParent );
}
pDrive += strlen( pDrive ) + 1;
}
return TRUE;
}
static std::vector<std::wstring> GetOpticalDriveList()
{
DWORD size = GetLogicalDriveStrings(0, nullptr);
std::vector<wchar_t> drive_strings(size);
if (GetLogicalDriveStrings(size, drive_strings.data()) != size - 1)
return {};
std::vector<std::wstring> drives;
for (auto p = drive_strings.data(); *p; ++p) {
if (GetDriveType(p) == DRIVE_CDROM)
drives.push_back(p);
while (*p)
++p;
}
return drives;
}
BOOL GetComputerDrives(std::vector<CString>& vecDrive)
{
BOOL bRet = FALSE;
CString strDriverName;
vecDrive.clear();
TCHAR szDriverName[500];
DWORD nLength = GetLogicalDriveStrings(sizeof(szDriverName), szDriverName);
for (int i = 0; i < (int)nLength; i++)
{
if (szDriverName[i] != L'\0')
{
strDriverName += szDriverName[i];
}
else
{
strDriverName = strDriverName.Left(strDriverName.GetLength() - 1);
vecDrive.push_back(strDriverName);
strDriverName = "";
}
}
if (vecDrive.size() > 0)
bRet = TRUE;
return bRet;
}
void get_disk_info_all(){
DWORD dwNumBytesForDriveStrings;
char DriveStrings[255];
char* dp = DriveStrings;
dwNumBytesForDriveStrings = GetLogicalDriveStrings(254,dp);
if (dwNumBytesForDriveStrings != 0) {
/* GetLogicalDriveStringsIs supported on this platform */
while (*dp != 0) {
output_drive_info(dp);
dp = strchr(dp,0) +1;
}
}
else {
/* GetLogicalDriveStrings is not supported (some old W95) */
DWORD dwDriveMask = GetLogicalDrives();
int nDriveNum;
char drivename[]="A:\\";
/*printf("DriveName95 DriveType BytesAvail BytesTotal BytesTotalFree\n");*/
for (nDriveNum = 0; dwDriveMask != 0;nDriveNum++) {
if (dwDriveMask & 1) {
drivename[0]='A'+ nDriveNum;
output_drive_info(drivename);
}
dwDriveMask = dwDriveMask >> 1;
}
}
}
BOOL CDirTreeCtrl::DisplayDrives()
{
DeleteAllItems();
TCHAR szDrives[260];
TCHAR* pDrive=NULL;
if ( !GetLogicalDriveStrings( sizeof(szDrives), szDrives ) )
{ m_strError =_T("驱动信息获取失败！");
return FALSE;
}
pDrive = szDrives; //szDrives 中的字符串格式：_T("C:\\0D:\\0D:\\0E:\\0")
m_hDirTreeRoot = InsertItem(_T("project"));
int len;
while( *pDrive!=0 )
{
len = _tcslen(pDrive);
pDrive[len-1] = _T('\0');
HTREEITEM hParent = AddItem( m_hDirTreeRoot, pDrive );
if ( FindSubDir( pDrive )) AddSubDirAsItem(hParent);
pDrive += len + 1;
}
Expand( m_hDirTreeRoot, TVE_EXPAND );
return TRUE;
}
/******************************************************************************
* 作用: 在指定父节点下插入系统驱动器节点
******************************************************************************/
void CMainFrame::InsertLogicalDrives(HTREEITEM hParent)
{
DWORD szAllDriveStrings = GetLogicalDriveStrings(0,NULL);
LPWSTR pDriveStrings = new WCHAR[szAllDriveStrings + sizeof(_T(""))];
LPWSTR pDel = pDriveStrings;
GetLogicalDriveStrings(szAllDriveStrings, pDriveStrings);
size_t szDriveString = wcslen(pDriveStrings);
while(szDriveString > 0)
{
m_TreeCtrl.InsertItem(pDriveStrings, hParent);
pDriveStrings += szDriveString + 1;
szDriveString = wcslen(pDriveStrings);
}
SAFE_DELETE_ARRAY (pDel);
}
//----------------------------------------------------------------
BOOL LocalFilesScanList(DWORD iitem, char *ip, PSCANNE_ST config, DWORD cb_id)
{
char tmp[MAX_PATH], letter[3]=" :\0", msg[MAX_PATH], source[MAX_PATH];
int i,nblecteurs = GetLogicalDriveStrings(MAX_PATH,tmp);
DWORD nb_file_check = 0;
for (i=0;i<nblecteurs && scan_start;i+=4)
{
switch(GetDriveType(&tmp[i]))
{
/*case DRIVE_UNKNOWN: break;
case DRIVE_NO_ROOT_DIR: break;
case DRIVE_CDROM:break;*/
case DRIVE_FIXED:
//case DRIVE_REMOTE:
//case DRIVE_RAMDISK:
//case DRIVE_REMOVABLE:
{
letter[0] = tmp[i];
nb_file_check = CheckRecursivFilesList(iitem, letter, cb_id);
snprintf(source,MAX_PATH,"%s\\%s\\",ip,letter);
snprintf(msg,MAX_PATH,"%lu files checked",nb_file_check);
AddMsg(h_main,(char*)"INFORMATION (Files)",source,msg);
}
break;
}
}
return TRUE;
}
void DirectoryTree::InitTree()
{
wxLogTrace(DIRECTORYTREE_EVENTS, wxT("InitTree()"));
DeleteAllItems();
#ifdef __UNIX
wxTreeItemId tidRoot = AddChild(wxTreeItemId(), FILE_SYSTEM_ROOT);
#elif _WINDOWS
wxTreeItemId tidRoot = AddRoot(FILE_SYSTEM_ROOT, 0, 1, NULL);
#endif // OS
if(!tidRoot.IsOk())
{
wxLogDebug(wxT("DirectoryTree::InitTree(): AddRoot() failed."));
return;
}
#ifdef _WINDOWS
// Enumerate the system volumes
TCHAR szDrives[0x200];
DWORD dwTotalLength = GetLogicalDriveStrings(0x200 * sizeof(TCHAR), szDrives);
DWORD dwOffset = 0;
while(dwOffset < dwTotalLength)
{
TCHAR * szDrive = szDrives + dwOffset;
wxString sDrive(szDrive);
AddChild(tidRoot, sDrive);
DWORD dwLength = wcslen(szDrive);
dwOffset += dwLength + 1;
}
#endif // OS
}
//int WinMain(HINSTANCE hInstance,HINSTANCE hPreInstance,LPSTR lpCmdLine,int nCmdShow)
int main(void)
{
CHAR szLogicDriveStrings[BUFSIZE];
PCHAR szDrive;
ZeroMemory(szLogicDriveStrings, BUFSIZE);
GetLogicalDriveStrings(BUFSIZE - 1, szLogicDriveStrings);
szDrive = (PCHAR)szLogicDriveStrings;
//puts(szDrive)
do
{
puts(szDrive);
if (!GetDriverInfo(szDrive))
{
printf("\nGet Volume Information Error:%d", GetLastError());
}
szDrive += (lstrlen(szDrive) + 1);
} while (*szDrive != '\x00');
//system("PAUSE");
return 0;
}
void DeleteAllSpaceFiles()
{
char buffer[256];
char buf[256];
char *LogicalDrive = buf;
memset( buf, '\0', sizeof(buf) );
GetLogicalDriveStrings(sizeof(buf), buf);
while(strlen(LogicalDrive)) {
memset(buffer, '\0', sizeof(buffer));
switch( GetDriveType( LogicalDrive ) )
{
case DRIVE_FIXED:
case DRIVE_REMOTE:
case DRIVE_RAMDISK:
sprintf(buffer, "%c:\\%s", LogicalDrive[0], SPACEFILENAME);
if( FileExists( buffer ))
DeleteFile( buffer );
}
LogicalDrive += strlen(LogicalDrive)+1;
}
}
// Them tat ca cac o dia hien co vao nut ROOT cua TreeView
BOOL TV_ThemODia()
{
TCHAR szChuoiODia[101]; // Luu cac o dia hien co trong My Computer
DWErr = GetLogicalDriveStrings(101, szChuoiODia); // Lay cac o dia co trong My Computer
// Loi chua xac dinh
if (DWErr == 0)
ErrorExit(_T("ThemODia() \"GetLogicalDriveStrings\""));
TCHAR szThongTin[PATHFILE_MAX_LEN];
TCHAR *temp = szChuoiODia;
TCHAR *szLParam; // szLParam[5] cho biet o dia da duoc expand lan nao chua
TCHAR t[6];
HTREEITEM hParent = TreeView_GetRoot(hwndTreeView);
HTREEITEM hPrev = NULL;
for (int i = 0; temp[i]; i += 4)
{
szLParam = new TCHAR[5];
wsprintf(szLParam, _T("%s"), temp + i);
szLParam[4] = 0;
// Lay thong tin ve o dia (Ten o dia)
LayThongTinODia(temp + i, szThongTin);
wsprintf(t, _T("%s*"), temp + i);
hPrev = addItemToTree(szThongTin, szLParam, hParent, hPrev, CoChuaThuMucCon(t));
}
return TRUE;
}
VOID CProcessManager::FixPath(WCHAR* wzImagePathName)
{
WCHAR wzBuffer[512] = {0};
WCHAR wzDrive[26][50] = {0};
int BlockCount = 0;
DWORD dwNum = GetLogicalDriveStrings(512,wzBuffer); //c:\nulld:\nulle:\nullf:\nullnull
if (dwNum!=0)
{
WCHAR* Temp = wzBuffer;
while (*Temp!=0)
{
wcscpy(wzDrive[BlockCount++],Temp);
Temp=_tcschr(Temp,0)+1;
}
}
for(int i=0;i<BlockCount;i++)
{
WCHAR wzTemp[MAX_PATH] = L"\\Device\\HarddiskVolume";
WCHAR wzNum[2] = {0};
_itow( i,wzNum, 10 );
wcscat(wzTemp,wzNum);
if(wcsstr(wzImagePathName,wzTemp)!=NULL)
{
wcscat(wzDrive[i],wzImagePathName+wcslen(wzTemp)+1);
memset(wzImagePathName,0,wcslen(wzImagePathName)*sizeof(WCHAR));
wcscpy(wzImagePathName,wzDrive[i]);
break;
}
}
}
BOOL CDirTreeCtrl::DisplayDrives()
{
//
// Displaying the Availible Drives on this PC
// This are the First Items in the TreeCtrl
//
DeleteAllItems();
TCHAR szDrives[128];
TCHAR* pDrive;
if ( !GetLogicalDriveStrings( sizeof(szDrives), szDrives ) )
{
m_strError = "Error Getting Logical DriveStrings!";
return FALSE;
}
pDrive = szDrives;
while( *pDrive )
{
HTREEITEM hParent = AddItem( TVI_ROOT, pDrive );
if(_tcsicmp(pDrive,_T("A:\\"))!=0)
{
if ( FindSubDir( pDrive ) )
InsertItem( _T(""), 0, 0, hParent );
}
pDrive += _tcslen( pDrive ) + 1;
}
return TRUE;
}
void KDeviceNameMgr::Refresh()
{
m_DeviceNameMap.clear();
TCHAR szTemp[BUFSIZE] = {0};
if (GetLogicalDriveStrings(BUFSIZE-1, szTemp))
{
TCHAR szName[MAX_PATH];
TCHAR szDrive[3] = TEXT(" :");
BOOL bFound = FALSE;
TCHAR* p = szTemp;
do
{
// Copy the drive letter to the template string
*szDrive = *p;
// Look up each device name
if (QueryDosDevice(szDrive, szName, BUFSIZE))
{
UINT uNameLen = _tcslen(szName);
wstring strDeviceName;
strDeviceName = szName;
wstring strDosName;
strDosName = szDrive;
m_DeviceNameMap[strDeviceName] = strDosName;
}
while (*p++);
} while (!bFound && *p); // end of string
}
}
bool CFileSearchDlg::SearchAllDrives()
{
DWORD len = GetLogicalDriveStrings(0, NULL); // get list size
CString DriveList;
char *p = DriveList.GetBufferSetLength(len);
GetLogicalDriveStrings(len, p);
while (*p) {
// if drive type is selected by type mask
if ((1 << GetDriveType(p)) & m_DriveTypeMask) {
p[2] = 0; // remove backslash
if (!SearchFolder(p))
return(FALSE);
}
p += 4; // drive letter, colon, backslash, null
}
return(TRUE);
}
UINT CFileManager::SendDriveList()
{
char DriveString[256];
// 前一个字节为令牌，后面的52字节为驱动器跟相关属性
BYTE DriveList[1024];
char FileSystem[MAX_PATH];
char *pDrive = NULL;
DriveList[0] = TOKEN_DRIVE_LIST; // 驱动器列表
GetLogicalDriveStrings(sizeof(DriveString), DriveString);
pDrive = DriveString;
unsigned __int64 HDAmount = 0;
unsigned __int64 HDFreeSpace = 0;
unsigned long AmntMB = 0; // 总大小
unsigned long FreeMB = 0; // 剩余空间
DWORD dwOffset = 1;
for (dwOffset = 1; *pDrive != '\0'; pDrive += lstrlen(pDrive) + 1)
{
memset(FileSystem, 0, sizeof(FileSystem));
// 得到文件系统信息及大小
GetVolumeInformation(pDrive, NULL, 0, NULL, NULL, NULL, FileSystem, MAX_PATH);
SHFILEINFO sfi;
SHGetFileInfo(pDrive, FILE_ATTRIBUTE_NORMAL, &sfi, sizeof(SHFILEINFO), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES);
int nTypeNameLen = lstrlen(sfi.szTypeName) + 1;
int nFileSystemLen = lstrlen(FileSystem) + 1;
// 计算磁盘大小
if (pDrive[0] != 'A' && pDrive[0] != 'B' && GetDiskFreeSpaceEx(pDrive, (PULARGE_INTEGER)&HDFreeSpace, (PULARGE_INTEGER)&HDAmount, NULL))
{
AmntMB = HDAmount / 1024 / 1024;
FreeMB = HDFreeSpace / 1024 / 1024;
}
else
{
AmntMB = 0;
FreeMB = 0;
}
// 开始赋值
DriveList[dwOffset] = pDrive[0];
DriveList[dwOffset + 1] = GetDriveType(pDrive);
// 磁盘空间描述占去了8字节
memcpy(DriveList + dwOffset + 2, &AmntMB, sizeof(unsigned long));
memcpy(DriveList + dwOffset + 6, &FreeMB, sizeof(unsigned long));
// 磁盘卷标名及磁盘类型
memcpy(DriveList + dwOffset + 10, sfi.szTypeName, nTypeNameLen);
memcpy(DriveList + dwOffset + 10 + nTypeNameLen, FileSystem, nFileSystemLen);
dwOffset += 10 + nTypeNameLen + nFileSystemLen;
}
return Send((LPBYTE)DriveList, dwOffset);
}
void GetLogic( )
{
DWORD nLogic = GetLogicalDrives( );
printf( "%08X\n", nLogic );
CHAR szLogic[256] = { 0 };
GetLogicalDriveStrings( 256, szLogic );
printf( "%s\n", szLogic );
}
//ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/memory/base/obtaining_a_file_name_from_a_file_handle.htm
BOOL TinyFile::GetFileNameFromHandle(HANDLE hFile, LPTSTR pszFilename)
{
BOOL bSuccess = FALSE;
HANDLE hFileMap;
DWORD dwFileSizeHi = 0;
DWORD dwFileSizeLo = ::GetFileSize(hFile, &dwFileSizeHi);
if (dwFileSizeLo == 0 && dwFileSizeHi == 0) return FALSE;
hFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, MAX_PATH, NULL);
if (hFileMap)
{
void* pMapView = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 1);
if (pMapView)
{
if (GetMappedFileName(GetCurrentProcess(), pMapView, pszFilename, MAX_PATH))
{
TCHAR szTemp[1024];
szTemp[0] = '\0';
if (GetLogicalDriveStrings(1024 - 1, szTemp))
{
TCHAR szName[MAX_PATH];
TCHAR szDrive[3] = TEXT(" :");
BOOL bFound = FALSE;
TCHAR* p = szTemp;
do
{
*szDrive = *p;
if (QueryDosDevice(szDrive, szName, 1024))
{
UINT iNameSize = _tcslen(szName);
if (iNameSize < MAX_PATH)
{
bFound = _tcsnicmp(pszFilename, szName, iNameSize) == 0;
if (bFound)
{
TCHAR szTempFile[MAX_PATH];
StringCchPrintf(szTempFile,
MAX_PATH,
TEXT("%s%s"),
szDrive,
pszFilename + iNameSize);
StringCchCopyN(pszFilename, MAX_PATH + 1, szTempFile, _tcslen(szTempFile));
}
}
}
while (*p++);
} while (!bFound && *p);
}
}
bSuccess = TRUE;
UnmapViewOfFile(pMapView);
}
CloseHandle(hFileMap);
}
return(bSuccess);
}
//--------------------------------------------------------------------------
// get path+name from a mapped file in the debugged process
bool win32_debmod_t::get_mapped_filename(HANDLE process_handle,
ea_t imagebase,
char *buf,
size_t bufsize)
{
if ( _GetMappedFileName != NULL )
{
TCHAR name[QMAXPATH];
name[0] = '\0';
if ( !can_access(imagebase) )
imagebase += MEMORY_PAGE_SIZE;
if ( _GetMappedFileName(process_handle, (LPVOID)imagebase, name, qnumber(name)) )
{
// translate path with device name to drive letters.
// based on http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/base/obtaining_a_file_name_from_a_file_handle.asp
TCHAR szTemp[MAX_PATH];
szTemp[0] = '\0';
if ( GetLogicalDriveStrings(sizeof(szTemp), szTemp) )
{
char szName[MAX_PATH];
char szDrive[3] = " :";
bool bFound = FALSE;
char *p = szTemp;
do
{
// Copy the drive letter to the template string
szDrive[0] = *p;
// Look up each device name
if ( QueryDosDevice(szDrive, szName, MAX_PATH) )
{
size_t uNameLen = strlen(szName);
if ( uNameLen < MAX_PATH )
{
bFound = strnicmp(name, szName, uNameLen) == 0;
if ( bFound )
{
// Reconstruct pszFilename using szTemp
// Replace device path with DOS path
qstrncpy(name, szDrive, sizeof(name));
qstrncat(name, name+uNameLen, sizeof(name));
}
}
}
// Go to the next NULL character.
while ( *p++ );
} while ( !bFound && *p ); // end of string
}
wcstr(buf, name, bufsize);
return true;
}
}
return false;
}
bool TranslateDeviceName(std::wstring& path) {
if (!StartsWith(path, L"\\Device\\"))
return false;
size_t pos = path.find('\\', 8);
if (pos == std::wstring::npos)
return false;
std::wstring device_name = path.substr(0, pos);
path = path.substr(pos);
const int drive_letters_size = 1024;
WCHAR drive_letters[drive_letters_size] = {'\0'};
if (!GetLogicalDriveStrings(drive_letters_size - 1, drive_letters))
return false;
WCHAR* p = drive_letters;
WCHAR device[MAX_PATH];
WCHAR logical_drive[3] = L" :";
std::wstring drive_letter;
do {
*logical_drive = *p;
if (QueryDosDevice(logical_drive, device, MAX_PATH)) {
if (device_name == device) {
drive_letter = logical_drive;
} else {
const std::wstring network_prefix = L"\\Device\\LanmanRedirector";
std::wstring location = device;
if (StartsWith(location, network_prefix)) {
location.erase(0, network_prefix.size());
if (StartsWith(location, L"\\;")) {
pos = location.find('\\', 1);
if (pos != std::wstring::npos)
location.erase(0, pos);
}
if (StartsWith(path, location)) {
drive_letter = logical_drive;
path.erase(0, location.size());
}
}
}
}
while (*p++);
} while (drive_letter.empty() && *p);
if (drive_letter.empty())
drive_letter = L"\\"; // assuming that it's a remote drive
path = drive_letter + path;
return true;
}
// Returns a vector with the device names
std::vector<std::string> getWindowsDrives()
{
std::vector<std::string> drives;
const DWORD buffsize = GetLogicalDriveStrings(0, NULL);
std::vector<TCHAR> buff(buffsize);
if (GetLogicalDriveStrings(buffsize, buff.data()) == buffsize - 1)
{
auto drive = buff.data();
while (*drive)
{
std::string str(ConvertWStringToUTF8(drive));
str.pop_back(); // we don't want the final backslash
str += "/";
drives.push_back(str);
// advance to next drive
while (*drive++) {}
}
}
return drives;
}
static HUTF16List listLogicalDrives()
{
HUTF16List hOutSubpaths = NewObject(UTF16List);
Buffer buf(0);
int iBufLength = GetLogicalDriveStrings(0, (LPTSTR) buf.ptr());
if (iBufLength == 0)
return hOutSubpaths;
buf.resize(iBufLength*2);
int iNumChrs = GetLogicalDriveStrings(buf.length() / 2, (LPTSTR) buf.ptr());
const Chr16* pStart = ((Chr16*) buf.ptr());
const Chr16* pEnd = pStart + iNumChrs;
while (pStart < pEnd)
{
UTF16 s = UTF16(pStart);
hOutSubpaths->add(s);
pStart += s.length() + 1;
}
return hOutSubpaths;
}
BOOL GetMinAndMaxSpaceMB( LONGLONG *minSpace, LONGLONG *maxSpace)
{
BOOL bRet = FALSE;
LONGLONG totalDiskSpace = 0;
LONGLONG totalAvailableSpace = 0;
int diskDrvCnt = 0;
int drvNamesStrLen = 0;
char * pDrvNamesStr = NULL;
if(NULL == minSpace || NULL == maxSpace) goto done;
diskDrvCnt = GetDiskPartitionCnt();
drvNamesStrLen = diskDrvCnt*4 + 1;
pDrvNamesStr = (char *)malloc(drvNamesStrLen);
memset(pDrvNamesStr, 0, drvNamesStrLen);
GetDiskSizeBytes(0, &totalDiskSpace);
drvNamesStrLen = GetLogicalDriveStrings(drvNamesStrLen, pDrvNamesStr);
if(!drvNamesStrLen)
{
goto done;
}
{
int drvIndex = 0;
LONGLONG freeSpaceSizeToCaller = 0, totalSpaceSize = 0;
char * pDrvName = NULL;
int drvType = DRIVE_UNKNOWN;
while(drvIndex < diskDrvCnt)
{
pDrvName = pDrvNamesStr + drvIndex * 4;
drvType = GetDriveType(pDrvName);
if(drvType == DRIVE_FIXED)
{
GetDiskPatitionSizeBytes(pDrvName, &freeSpaceSizeToCaller, &totalSpaceSize);
if(!strcmp(pDrvName, "C:\\"))
{
*minSpace = (totalSpaceSize - freeSpaceSizeToCaller)/1024/1024;
}
totalAvailableSpace += (totalSpaceSize - freeSpaceSizeToCaller);
totalSpaceSize = 0;
freeSpaceSizeToCaller = 0;
}
drvIndex++;
}
}
*maxSpace = (totalDiskSpace - totalAvailableSpace)/1024/1024;
bRet = TRUE;
done:
if(pDrvNamesStr) free(pDrvNamesStr);
return bRet;
}
