自学教程：C++ GetLogicalDriveStrings函数代码示例

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 intsync_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 TreeViewBOOL 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 processbool 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 namesstd::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;}