static int max_filename() { DWORD maxflen; int status = 0; status = GetVolumeInformation((LPTSTR)0, (LPTSTR)0, 0 , (LPDWORD)0, &maxflen, (LPDWORD)0, (LPTSTR)0, 0); if (status) return maxflen; else return 0; }
String GetVolumeSn(const String &vol, int len) { dword sn; // Win API if(!GetVolumeInformation(vol, NULL, 0, &sn, NULL, NULL, NULL, 0)) sn = 71511731; #ifdef _WITH_DEBUG RLOG("GetVolumeSn():sn = " + AsString(sn)); #endif return String(AsString(sn)).Right(len); }
/* Tony Hoyle's function for testing whether a given volume uses UTC or * local time to record file modification times * * Reproduced here with permission of Tony Hoyle. * * This code is copyright by Tony Hoyle and is licensed under the Gnu * Public License. (See above) * * NTFS, HPFS, and OWFS store file times as UTC times. * FAT stores file times as local time. * * INPUTS: * LPCSTR name: fully qualified path * * OUTPUTS: * Return true if the file system on the volume in question * stores file times as UTC */ BOOL IsUTCVolume ( LPCTSTR name ) { _TCHAR szDrive[_MAX_DRIVE + 1] = _T(""); _TCHAR szFs[32]=_T(""); _tsplitpath(name, szDrive, NULL, NULL, NULL); _tcscat(szDrive, _T("\\")); GetVolumeInformation( szDrive, NULL, 0, NULL, NULL, NULL, szFs, 32 ); return ! ( _tcsicmp( szFs, _T("NTFS") ) && _tcsicmp( szFs, _T("HPFS") ) && _tcsicmp( szFs, _T("OWFS") ) ); }
//=========================================================================== void __fastcall TfrmMain::FormCreate(TObject *Sender) { // --------------------------------------------------- frmLogoDiALab = new TfrmLogoDiALab(NULL); //frmLogoDiALab->Show(); Application->ProcessMessages(); Sleep(2300); // --------------------------------------------------- WhoUseProgram = wupSensei; //WhoUseProgram = wupTsisarzh; //WhoUseProgram = wupTanjaKvant; if (WhoUseProgram == wupTsisarzh) { // ---- ѕровер¤ем винты ------// || WhoUseProgram == wupSensei unsigned long aa = MAX_PATH; char VolumeName[MAX_PATH], FileSystemName[MAX_PATH]; unsigned long VolumeSerialNo; unsigned long MaxComponentLength, FileSystemFlags; GetVolumeInformation("C:\\", VolumeName, aa, &VolumeSerialNo, &MaxComponentLength,&FileSystemFlags, FileSystemName,aa); AnsiString HexVolumeSerialNo = IntToHex((int)VolumeSerialNo,8); if ( HexVolumeSerialNo != "0D471DF1" && HexVolumeSerialNo != "104E16FB" && HexVolumeSerialNo != "256E13FC") { Error_None_LicenseProgram(Handle); ExitProcess(0); } } // --------------------------------------------------- Left = 0; Top = 0; Height = 730; EnabledTVModivication = true; // ---- –егистрирую в ¬индовсе расширение ------------ RegisterFileType("dls", Application->ExeName, 1); AddNewFileToMainMenu(pmFile, "Load", LoadProjectFromMenu); // ------- «аполн¤ем “ри¬ью —писками элементов ----- SetupTreeView(); // ------- aAllAction(aNewScheme); // ------- »нициализаци¤ пути ќпен и —айф ƒиалога -------- OpenDialog1->InitialDir = ExtractFilePath( Application->ExeName ); SaveDialog1->InitialDir = ExtractFilePath( Application->ExeName ); // ----- TimerLogo->Enabled = true; }
void Win32DiskInfoProvider::ConstructInfo() { TCHAR VolumeNameBuffer[MAX_PATH+1]; DWORD VolumeSerialNumber=0; DWORD MaximumComponentLength=0; DWORD FileSystemFlags=0; TCHAR FileSystemNameBuffer[MAX_PATH+1]; BOOL b = GetVolumeInformation(driveName.c_str(), VolumeNameBuffer, MAX_PATH+1, &VolumeSerialNumber, &MaximumComponentLength, &FileSystemFlags, FileSystemNameBuffer, MAX_PATH+1); if (!b) { valid = false; info = "error"; return; } ULARGE_INTEGER totalNrBytes; totalNrBytes.QuadPart = 0; GetDiskFreeSpaceEx(driveName.c_str(), NULL, &totalNrBytes, NULL); std::string strType; switch (GetDriveType(driveName.c_str())) { case DRIVE_UNKNOWN: strType += "unknown volume type"; break; case DRIVE_NO_ROOT_DIR: strType += "invalid root dir"; break; case DRIVE_REMOVABLE: strType += "removable volume"; break; case DRIVE_FIXED: strType += "fixed volume"; break; case DRIVE_REMOTE: strType += "remote volume"; break; case DRIVE_CDROM: strType += "CD-ROM"; break; case DRIVE_RAMDISK: strType += "RAM disk"; break; } info = driveName+ " type:<"+strType+ ">, name:<"+VolumeNameBuffer+ ">, system name:<"+FileSystemNameBuffer+ ">, "+RichBool::ToString(totalNrBytes)+" bytes"; }
BOOL IsVolumeNTFS( PWCHAR path ) { // // Scan backwards through the path looking for \ and trying at each level until we // get to the root. We'll terminate it there and pass it to GetVolumeInformation // PWCHAR LastBackSlash = path + wcslen( path ); WCHAR c; BOOL b; ULONG i; WCHAR PhysicalName[MAX_PATH]; while (TRUE) { while (TRUE) { if (LastBackSlash < path) { DisplayError(); return FALSE; } if (*LastBackSlash == L'\\') { break; } LastBackSlash--; } c = LastBackSlash[1]; LastBackSlash[1] = L'\0'; b = GetVolumeInformation( path, NULL, 0, NULL, &i, &i, PhysicalName, sizeof(PhysicalName)/sizeof(WCHAR) ); LastBackSlash[1] = c; LastBackSlash--; if ( b ) { return _wcsicmp( PhysicalName, L"NTFS" ) == 0; } } }
// turn a file, relative path or other into an absolute path BOOL AFXAPI AfxFullPath(LPTSTR lpszPathOut, LPCTSTR lpszFileIn) // lpszPathOut = buffer of _MAX_PATH // lpszFileIn = file, relative path or absolute path // (both in ANSI character set) { ASSERT(AfxIsValidAddress(lpszPathOut, _MAX_PATH)); // first, fully qualify the path name LPTSTR lpszFilePart; if (!GetFullPathName(lpszFileIn, _MAX_PATH, lpszPathOut, &lpszFilePart)) { #ifdef _DEBUG if (lpszFileIn[0] != '\0') TRACE1("Warning: could not parse the path '%s'.\n", lpszFileIn); #endif lstrcpyn(lpszPathOut, lpszFileIn, _MAX_PATH); // take it literally return FALSE; } #ifndef _MAC CString strRoot; // determine the root name of the volume AfxGetRoot(lpszPathOut, strRoot); // get file system information for the volume DWORD dwFlags, dwDummy; if (!GetVolumeInformation(strRoot, NULL, 0, NULL, &dwDummy, &dwFlags, NULL, 0)) { TRACE1("Warning: could not get volume information '%s'.\n", (LPCTSTR)strRoot); return FALSE; // preserving case may not be correct } // not all characters have complete uppercase/lowercase if (!(dwFlags & FS_CASE_IS_PRESERVED)) CharUpper(lpszPathOut); // assume non-UNICODE file systems, use OEM character set if (!(dwFlags & FS_UNICODE_STORED_ON_DISK)) { WIN32_FIND_DATA data; HANDLE h = FindFirstFile(lpszFileIn, &data); if (h != INVALID_HANDLE_VALUE) { FindClose(h); lstrcpy(lpszFilePart, data.cFileName); } } #endif return TRUE; }
bool GetHdiskID(TCHAR DiskID[10]) { DWORD Serial; DWORD Length; BOOL success = GetVolumeInformation(_T("C:\\"), NULL, MAX_PATH, &Serial, &Length, NULL, NULL, MAX_PATH); if (!success) { return false; } wsprintf(DiskID, _T("%x"), Serial); return true; }
void TautoPresetProps::getVolume(void) { const char_t *flnm=deci->getSourceName(); char_t dsk[MAX_PATH]; _splitpath_s(flnm,dsk,MAX_PATH,NULL,0,NULL,0,NULL,0); DWORD serial,maximumComponentLength,volumeFlags; ffstring disk(dsk); disk += _l("\\"); wasVolume=GetVolumeInformation(disk.c_str(),volumeName,256,&serial,&maximumComponentLength,&volumeFlags,NULL,0); if (wasVolume) { tsnprintf_s(volumeSerial, countof(volumeSerial), _TRUNCATE, _l("%X-%X"),(int)HIWORD(serial),(int)LOWORD(serial)); } }
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; }
boost::uint32_t get_host_id() { #ifdef UHD_PLATFORM_WIN32 //extract volume serial number char szVolName[MAX_PATH+1], szFileSysName[MAX_PATH+1]; DWORD dwSerialNumber, dwMaxComponentLen, dwFileSysFlags; GetVolumeInformation("C:\\", szVolName, MAX_PATH, &dwSerialNumber, &dwMaxComponentLen, &dwFileSysFlags, szFileSysName, sizeof(szFileSysName)); return boost::uint32_t(dwSerialNumber); #else return boost::uint32_t(gethostid()); #endif }
bool CVolumeDescriptionEnumeratorThread::GetDrive(const wxChar* pDrive, const int len) { wxChar* pVolume = new wxChar[len + 1]; wxStrcpy(pVolume, pDrive); if (pVolume[len - 1] == '\\') pVolume[len - 1] = 0; if (!*pVolume) { delete [] pVolume; return false; } // Check if it is a network share wxChar *share_name = new wxChar[512]; DWORD dwSize = 511; if (!WNetGetConnection(pVolume, share_name, &dwSize)) { m_crit_section.Enter(); t_VolumeInfoInternal volumeInfo; volumeInfo.pVolume = pVolume; volumeInfo.pVolumeName = share_name; m_volumeInfo.push_back(volumeInfo); m_crit_section.Leave(); pDrive += len + 1; return true; } else delete [] share_name; // Get the label of the drive wxChar* pVolumeName = new wxChar[501]; int oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS); BOOL res = GetVolumeInformation(pDrive, pVolumeName, 500, 0, 0, 0, 0, 0); SetErrorMode(oldErrorMode); if (res && pVolumeName[0]) { m_crit_section.Enter(); t_VolumeInfoInternal volumeInfo; volumeInfo.pVolume = pVolume; volumeInfo.pVolumeName = pVolumeName; m_volumeInfo.push_back(volumeInfo); m_crit_section.Leave(); return true; } delete [] pVolumeName; delete [] pVolume; return false; }
std::string volume_name(const std::string &path) { wchar_t volume_name[MAX_PATH + 1]; if (GetVolumeInformation( to_windows_path(path).c_str(), volume_name, sizeof(volume_name) / sizeof(*volume_name), NULL, NULL, NULL, NULL, 0)) { return from_utf16(volume_name); } return std::string(); }
/* * Class: sage_Sage * Method: getFileSystemType * Signature: (Ljava/lang/String;)Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_sage_Sage_getFileSystemType(JNIEnv *env, jclass jc, jstring volRoot) { const char* rootStr = env->GetStringUTFChars(volRoot, 0); DWORD maxNameLen; DWORD fsFlags; TCHAR daBuf[64]; jstring rv; if (GetVolumeInformation(rootStr, NULL, 0, NULL, &maxNameLen, &fsFlags, daBuf, 64)) rv = env->NewStringUTF(daBuf); else rv = NULL; env->ReleaseStringUTFChars(volRoot, rootStr); return rv; }
BOOL is_ntfs(const char * file) { char drive[255]; char FSType[20]; char tmpbuf[256]; char *machinename; char *sharename; char filename[1024]; REQUIRE(filename != NULL); if (isc_file_absolutepath(file, filename, sizeof(filename)) != ISC_R_SUCCESS) { return (FALSE); } /* * Look for c:\path\... style, c:/path/... or \\computer\shar\path... * the UNC style file specs */ if (isalpha(filename[0]) && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/')) { strncpy(drive, filename, 3); drive[3] = '\0'; } else if ((filename[0] == '\\') && (filename[1] == '\\')) { /* Find the machine and share name and rebuild the UNC */ strcpy(tmpbuf, filename); machinename = strtok(tmpbuf, "\\"); sharename = strtok(NULL, "\\"); strcpy(drive, "\\\\"); strcat(drive, machinename); strcat(drive, "\\"); strcat(drive, sharename); strcat(drive, "\\"); } else /* Not determinable */ return (FALSE); GetVolumeInformation(drive, NULL, 0, NULL, 0, NULL, FSType, sizeof(FSType)); if(strcmp(FSType,"NTFS") == 0) return (TRUE); else return (FALSE); }
/* * pathconf - * return: * path(in): * name(in): * * Note: */ long pathconf (char *path, int name) { long namelen; long filesysflags; switch (name) { case _PC_PATH_MAX: /* * NT and OS/2 file systems claim to be able to handle 255 char * file names. But none of the system calls seem to be able to * handle a path of more than 255 chars + 1 NULL. Nor does there * appear to be a system function to return the real max length. * MAX_PATH is defined in stdlib.h on the NT system. */ return ((MAX_PATH - 1)); case _PC_NAME_MAX: if (GetVolumeInformation (NULL, NULL, 0, NULL, (LPDWORD) & namelen, (LPDWORD) & filesysflags, NULL, 0)) { /* WARNING!, for "old" DOS style file systems, namelen will be 12 * right now, totaling the 8 bytes for name with the 3 bytes for * for extension plus a dot. This ISN'T what the caller wants, * It really wants the maximum size of an unqualified pathname. * I'm not sure what this works out to be under the new file system. * We probably need to make a similar adjustment but hopefully * we'll have more breathing room. */ if (namelen == 12) namelen = 8; return (namelen); } else { return (8); /* Length of MSDOS file name */ } case _PC_NO_TRUNC: return (TRUE); default: return (-1); } }
MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_CanSecure (MonoString *root) { #if HOST_WIN32 gint32 flags; /* ACL are nice... unless you have FAT or other uncivilized filesystem */ if (!GetVolumeInformation (mono_string_chars (root), NULL, 0, NULL, NULL, (LPDWORD)&flags, NULL, 0)) return FALSE; return ((flags & FS_PERSISTENT_ACLS) == FS_PERSISTENT_ACLS); #else /* we assume some kind of security is applicable outside Windows */ return TRUE; #endif }
APIRET os2APIENTRY DosQueryFSAttach(PCSZ pszDeviceName, ULONG /*ulOrdinal*/, ULONG ulFSAInfoLevel, PFSQBUFFER2 pfsqb, PULONG /*pcbBuffLength*/) { //FixMe: handle devices too if(ulFSAInfoLevel!=FSAIL_QUERYNAME) return 124; //invalid level UINT dt = GetDriveType(pszDeviceName); switch(dt) { case DRIVE_REMOVABLE: pfsqb->iType = FSAT_LOCALDRV; break; case DRIVE_FIXED: pfsqb->iType = FSAT_LOCALDRV; break; case DRIVE_REMOTE: pfsqb->iType = FSAT_REMOTEDRV; break; case DRIVE_CDROM: pfsqb->iType = FSAT_LOCALDRV; break; case DRIVE_RAMDISK: pfsqb->iType = FSAT_LOCALDRV; break; default: return 15; //invalid drive } char volumeNameBuffer[256]; DWORD mcl; DWORD fsf; char fsNameBuffer[256]; if(!GetVolumeInformation(pszDeviceName, volumeNameBuffer, 256, 0, &mcl, &fsf, fsNameBuffer, 256 )) return (APIRET)GetLastError(); pfsqb->cbName = (USHORT)strlen(fsNameBuffer); strcpy((char*)pfsqb->szName,fsNameBuffer); pfsqb->cbFSDName = (USHORT)strlen(fsNameBuffer); strcpy((char*)pfsqb->szName+pfsqb->cbName+1,fsNameBuffer); pfsqb->cbFSAData = 0; return 0; }
/* * PrintDirectoryHeader * * print the header for the dir command */ static BOOL PrintDirectoryHeader(LPTSTR szPath, LPDIRSWITCHFLAGS lpFlags) { TCHAR szMsg[RC_STRING_MAX_SIZE]; TCHAR szFullDir[MAX_PATH]; TCHAR szRootName[MAX_PATH]; TCHAR szVolName[80]; LPTSTR pszFilePart; DWORD dwSerialNr; if (lpFlags->bBareFormat) return TRUE; if (GetFullPathName(szPath, sizeof(szFullDir) / sizeof(TCHAR), szFullDir, &pszFilePart) == 0) { ErrorMessage(GetLastError(), _T("Failed to build full directory path")); return FALSE; } if (pszFilePart != NULL) *pszFilePart = _T('\0'); /* get the media ID of the drive */ if (!GetVolumePathName(szFullDir, szRootName, sizeof(szRootName) / sizeof(TCHAR)) || !GetVolumeInformation(szRootName, szVolName, 80, &dwSerialNr, NULL, NULL, NULL, 0)) { return(TRUE); } /* print drive info */ if (szVolName[0] != _T('\0')) { LoadString(CMD_ModuleHandle, STRING_DIR_HELP2, szMsg, RC_STRING_MAX_SIZE); DirPrintf(lpFlags, szMsg, szRootName[0], szVolName); } else { LoadString(CMD_ModuleHandle, STRING_DIR_HELP3, szMsg, RC_STRING_MAX_SIZE); DirPrintf(lpFlags, szMsg, szRootName[0]); } /* print the volume serial number if the return was successful */ LoadString(CMD_ModuleHandle, STRING_DIR_HELP4, (LPTSTR) szMsg, RC_STRING_MAX_SIZE); DirPrintf(lpFlags, szMsg, HIWORD(dwSerialNr), LOWORD(dwSerialNr)); return TRUE; }
DWORD GetSystemVolumeSerial(char *szSystemVolume) { char *lpszVolumeName, *lpszFileSystemName; DWORD dwVolumeSerialNumber = 0xFFFFFFFF, dwMaximumComponentLength, dwFileSystemFlags; lpszVolumeName = (char *)malloc(MAX_PATH + 1); if(lpszVolumeName != NULL){ lpszFileSystemName = (char *)malloc(MAX_PATH * 1); if(lpszFileSystemName != NULL){ GetVolumeInformation(szSystemVolume, lpszVolumeName, MAX_PATH + 1, &dwVolumeSerialNumber, &dwMaximumComponentLength, &dwFileSystemFlags, lpszFileSystemName, MAX_PATH + 1); free(lpszFileSystemName); } free(lpszVolumeName); } return dwVolumeSerialNumber; }
bool FileSystemManager::resolveVolumeName( QString volume, QString& volumeNameOut ) { if (!exists(volume)) return false; // derive the drive name from the drive letter TCHAR volumeName[MAX_PATH]; volumeNameOut = QString("Removable Disk (%1)").arg(volume); if (GetVolumeInformation((LPCTSTR) volume.utf16(), volumeName, MAX_PATH, NULL, NULL, NULL, NULL, 0)) { QString tmp = QString::fromUtf16((const ushort *) volumeName); if (!tmp.isEmpty()) volumeNameOut = tmp; } return true; }
/*------------------------------------------------------------------------------------ FUNCTION NAME: GetSerialNumber DESCRIPTION: Get serial number from BIOS. PARAMETERS: - INPUT: - OUTPUT: RETURN: - TRUE : Get information correctly. - FALSE : Not get information correctly. NOTES: ------------------------------------------------------------------------------------*/ BOOL GetSerialNumber (DWORD * pSerialNumber, char * RootDirectory) { char _volume_name [MAX_MGL_STRINGS]; char _file_system_name [MAX_MGL_STRINGS]; DWORD _size; DWORD _serial_number, _max_component_length, _file_system_flags; BOOL _rc; _size = MAX_MGL_STRINGS; _rc = GetVolumeInformation (RootDirectory, _volume_name, _size, &_serial_number, &_max_component_length, &_file_system_flags, _file_system_name, _size); *pSerialNumber = _serial_number; return _rc; } /* GetSerialNumber */
bool IsFilenameOnFATVolume(const char *pszFilename) { char szFileRoot[MAX_PATH]; DWORD dwMaxComponentLength; DWORD dwFSFlags; char szFilesystem[MAX_PATH]; if (!GetVolumeInformation(SplitPathRoot(szFileRoot, pszFilename), NULL, 0, // Volume name buffer NULL, // Serial number buffer &dwMaxComponentLength, &dwFSFlags, szFilesystem, sizeof szFilesystem)) return false; return !strnicmp(szFilesystem, "FAT", 3); }
//--------------------------------------------------------------------------- // Returns the type of filesystem that a file resides on. // AnsiString GetFileSystemType(AnsiString FileName) { AnsiString retval; char *VolumeName, *FileSystemName; DWORD VolumeSerialNumber, MaxComponentLength, FileSystemFlags; bool success; VolumeName = new char[MAX_PATH]; FileSystemName = new char[MAX_PATH]; success = GetVolumeInformation((ExtractFileDrive(FileName) + "\\").c_str(), VolumeName, MAX_PATH, &VolumeSerialNumber, &MaxComponentLength, &FileSystemFlags, FileSystemName, 64); if (success) retval = String(FileSystemName); delete VolumeName; delete FileSystemName; return String(FileSystemName); } // AnsiString GetFileSystemType(AnsiString FileName)
static BOOL mediaInDrive(const char *drive) { UINT oldErrorMode; DWORD tmp; BOOL retval; /* Prevent windows warning message appearing when checking media size */ oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS); /* If this function succeeds, there's media in the drive */ retval = GetVolumeInformation(drive, NULL, 0, NULL, NULL, &tmp, NULL, 0); /* Revert back to old windows error handler */ SetErrorMode(oldErrorMode); return(retval); } /* mediaInDrive */
void InitDrive(int i){ WCHAR name[4]; g_bVols[i]=1; swprintf(name,4,L"%c:\\",i+'A'); g_VolsInfo[i].type = GetDriveType(name); if(g_VolsInfo[i].type==DRIVE_FIXED){ if(IsUsbDriver(i)) g_VolsInfo[i].type=DRIVE_REMOVABLE; } { WCHAR volumeName[32]; WCHAR fsName[8]; GetVolumeInformation(name,volumeName,32,&g_VolsInfo[i].serialNumber,NULL,NULL,fsName,8); wchar_to_utf8_nocheck(volumeName, 32, g_VolsInfo[i].volumeName, 56); wchar_to_utf8_nocheck(fsName, 8, g_VolsInfo[i].fsName, 8); } get_drive_space(i); }
/** * \class MediaMonitorWindows * * I am assuming, for now, that everything on Windows uses drive letters * (e.g. C:, D:). That is probably wrong, though. (other APIs?) */ MediaMonitorWindows::MediaMonitorWindows(QObject* par, unsigned long interval, bool allowEject) : MediaMonitor(par, interval, allowEject) { char strDrives[128]; if (!::GetLogicalDriveStrings(sizeof(strDrives), strDrives)) return; for (char *driveName = strDrives; *driveName; driveName += strlen(driveName) + 1) { uint type = ::GetDriveType(driveName); if (type != DRIVE_REMOVABLE && type != DRIVE_CDROM) continue; MythMediaDevice *media = NULL; if (type == DRIVE_CDROM) media = MythCDROM::get(this, driveName, false, allowEject); else media = MythHDD::Get(this, driveName, false, allowEject); if (!media) { VERBOSE(VB_IMPORTANT, "Error. Couldn't create MythMediaDevice."); return; } // We store the volume name to improve // user activities like ChooseAndEjectMedia(). char volumeName[MAX_PATH]; if (GetVolumeInformation(driveName, volumeName, MAX_PATH, NULL, NULL, NULL, NULL, NULL)) { media->setVolumeID(volumeName); } AddDevice(media); } VERBOSE(VB_MEDIA, "Initial device list: " + listDevices()); }
bool GetMachineID(std::string &info) { const int CBuffSize = 256; // get windows path std::wstring dir; { wchar_t buff[CBuffSize]; int len = GetWindowsDirectory(buff, CBuffSize); if (len > CBuffSize) return false; dir += buff; } // get volume info DWORD volumeID; { wchar_t volume[CBuffSize]; wchar_t fsName[CBuffSize]; DWORD componentLength, systemFlags; bool ok = GetVolumeInformation( dir.substr(0, 3).c_str(), volume, CBuffSize, &volumeID, &componentLength, &systemFlags, fsName, CBuffSize ); if (!ok) return false; } // volume id -> md5 -> base64 std::string volumeIdHash; Utils::MD5::Digest(&volumeID, sizeof(volumeID), volumeIdHash); Utils::Base64::Encode(volumeIdHash, info); return true; }
bool MyGetVolumeInformation( LPCTSTR rootPathName, CSysString &volumeName, LPDWORD volumeSerialNumber, LPDWORD maximumComponentLength, LPDWORD fileSystemFlags, CSysString &fileSystemName) { bool result = BOOLToBool(GetVolumeInformation( rootPathName, volumeName.GetBuffer(MAX_PATH), MAX_PATH, volumeSerialNumber, maximumComponentLength, fileSystemFlags, fileSystemName.GetBuffer(MAX_PATH), MAX_PATH)); volumeName.ReleaseBuffer(); fileSystemName.ReleaseBuffer(); return result; }
BOOL IsVolumeLocalNTFS( WCHAR DriveLetter ) { BOOL b; ULONG i; WCHAR DosName[16]; WCHAR PhysicalName[MAX_PATH]; DosName[0] = DriveLetter; DosName[1] = L':'; DosName[2] = L'\\'; DosName[3] = L'\0'; switch (GetDriveType( DosName )) { case DRIVE_UNKNOWN: case DRIVE_REMOTE: return FALSE; } b = GetVolumeInformation( DosName, NULL, 0, NULL, &i, &i, PhysicalName, sizeof(PhysicalName)/sizeof(WCHAR) ); if (!b ) { DisplayError(); return FALSE; } if (_wcsicmp( PhysicalName, L"NTFS" ) != 0) { return FALSE; } return TRUE; }