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; }