__int64 PlatFormSpecific()
{
BYTE Buffer[0x400];
DWORD BufSz = 0x400;
int Idx, Used;
Used = Idx = 0;
if (QueryRegValue(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\ProductId",
(LPBYTE)Buffer, &BufSz))
Used += BufSz;
BufSz = sizeof(Buffer)-Used;
if (QueryRegValue(HKEY_LOCAL_MACHINE,
"HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter\\*\\DiskController\\*\\DiskPeripheral\\*\\Identifier",
(LPBYTE)Buffer + Used, &BufSz))
Used += BufSz;
#ifdef SKYPE5
else
{
*((unsigned int*)&Buffer[Used]) = FillAdaptersInfo((unsigned int*)&Buffer[Used+4]);
Used+=8;
}
#endif
if (GetVolumeInformationA("C:\\", 0, 0, (LPDWORD)(Buffer + Used), 0, 0, 0, 0))
Used+=4;
return BytesSHA1I64(Buffer, Used);
}
bool IsFilenameOnFATVolume(const wchar_t *pszFilename) {
VDStringW rootPath(VDFileGetRootPath(pszFilename));
if (VDIsWindowsNT()) {
DWORD dwMaxComponentLength;
DWORD dwFSFlags;
wchar_t szFilesystem[MAX_PATH];
if (!GetVolumeInformationW(rootPath.c_str(),
NULL, 0, // Volume name buffer
NULL, // Serial number buffer
&dwMaxComponentLength,
&dwFSFlags,
szFilesystem,
MAX_PATH))
return false;
return !_wcsnicmp(szFilesystem, L"FAT", 3);
} else {
DWORD dwMaxComponentLength;
DWORD dwFSFlags;
char szFilesystem[MAX_PATH];
if (!GetVolumeInformationA(VDTextWToA(rootPath).c_str(),
NULL, 0, // Volume name buffer
NULL, // Serial number buffer
&dwMaxComponentLength,
&dwFSFlags,
szFilesystem,
sizeof szFilesystem))
return false;
return !_strnicmp(szFilesystem, "FAT", 3);
}
}
void FillMiscDatas(unsigned int *Datas)
{
BYTE Buffer[0x400];
HKEY rKey;
DWORD BufSz = 0x400;
int ret;
double PlatForm;
PlatForm = PlatFormSpecific();
Datas[0] = *(unsigned int *)&PlatForm;
Datas[1] = *(unsigned int *)GetNodeId();
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion", 0, KEY_QUERY_VALUE, &rKey);
if (ret)
return ;
ret = RegQueryValueExA(rKey, "ProductId", NULL, NULL, (LPBYTE)Buffer, &BufSz);
if (ret)
return ;
RegCloseKey(rKey);
Datas[2] = BytesSHA1(Buffer, BufSz);
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter\\8\\DiskController\\0\\DiskPeripheral\\0", 0, KEY_QUERY_VALUE, &rKey);
if (ret)
return ;
ret = RegQueryValueExA(rKey, "Identifier", NULL, NULL, (LPBYTE)Buffer, &BufSz);
if (ret)
return ;
RegCloseKey(rKey);
Datas[3] = BytesSHA1(Buffer, BufSz);
ret = GetVolumeInformationA("C:\\", 0, 0, (LPDWORD)Buffer, 0, 0, 0, 0);
Datas[4] = BytesSHA1(Buffer, 0x04);
}
/********************************************************************
* WNetGetConnection [USER.512] reverse-resolves a local device
*/
WORD WINAPI WNetGetConnection16( LPSTR lpLocalName,
LPSTR lpRemoteName, UINT16 *cbRemoteName )
{
char label[32];
TRACE( "local %s\n", lpLocalName );
switch(GetDriveTypeA(lpLocalName))
{
case DRIVE_REMOTE:
GetVolumeInformationA( lpLocalName, label, sizeof(label), NULL, NULL, NULL, NULL, 0 );
if (strlen(label) + 1 > *cbRemoteName)
{
*cbRemoteName = strlen(label) + 1;
return WN16_MORE_DATA;
}
strcpy( lpRemoteName, label );
*cbRemoteName = strlen(lpRemoteName) + 1;
return WN16_SUCCESS;
case DRIVE_REMOVABLE:
case DRIVE_FIXED:
case DRIVE_CDROM:
TRACE("file is local\n");
return WN16_NOT_CONNECTED;
default:
return WN16_BAD_LOCALNAME;
}
}
double PlatFormSpecific()
{
BYTE Buffer[0x400];
HKEY rKey;
DWORD BufSz = 0x400;
int Idx, Used, ret;
Used = Idx = 0;
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion", 0, KEY_QUERY_VALUE, &rKey);
if (ret)
return (0);
ret = RegQueryValueExA(rKey, "ProductId", NULL, NULL, (LPBYTE)Buffer, &BufSz);
if (ret)
return (0);
RegCloseKey(rKey);
Used += BufSz;
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter\\8\\DiskController\\0\\DiskPeripheral\\0", 0, KEY_QUERY_VALUE, &rKey);
if (ret)
return (0);
ret = RegQueryValueExA(rKey, "Identifier", NULL, NULL, (LPBYTE)Buffer + Used, &BufSz);
if (ret)
return (0);
RegCloseKey(rKey);
Used += BufSz;
ret = GetVolumeInformationA("C:\\", 0, 0, (LPDWORD)(Buffer + Used), 0, 0, 0, 0);
return BytesSHA1d(Buffer, Used + 0x04);
}
void FillMiscDatas(Skype_Inst *pInst, unsigned int *Datas)
{
BYTE Buffer[0x400];
DWORD BufSz = 0x400;
int ret;
int64_t PlatForm;
PlatForm = PlatFormSpecific();
Datas[0] = *(unsigned int *)&PlatForm;
Datas[1] = *(unsigned int *)&pInst->NodeID;
if (!QueryRegValue(HKEY_LOCAL_MACHINE,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\ProductId",
(LPBYTE)Buffer, &BufSz))
return;
Datas[2] = BytesSHA1(Buffer, BufSz);
BufSz = 0x400;
if (!QueryRegValue(HKEY_LOCAL_MACHINE,
"HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter\\*\\DiskController\\*\\DiskPeripheral\\*\\Identifier",
(LPBYTE)Buffer, &BufSz))
return;
Datas[3] = BytesSHA1(Buffer, BufSz);
ret = GetVolumeInformationA("C:\\", 0, 0, (LPDWORD)Buffer, 0, 0, 0, 0);
Datas[4] = BytesSHA1(Buffer, 0x04);
}
/*************************************************************************
* IsLFNDrive [SHELL32.119]
*
* NOTES
* exported by ordinal Name
*/
BOOL WINAPI IsLFNDriveA(LPCSTR lpszPath)
{
DWORD fnlen;
if (!GetVolumeInformationA(lpszPath,NULL,0,NULL,&fnlen,NULL,NULL,0))
return FALSE;
return fnlen>12;
}
BOOL check_path(char* path)
{
UINT type = GetDriveTypeA(path);
if (!(type == DRIVE_REMOVABLE || type == DRIVE_CDROM || type == DRIVE_REMOTE))
return FALSE;
return GetVolumeInformationA(path, NULL, 0, NULL, NULL, NULL, NULL, 0);
}
std::string ID::GetSerialNumber(void)
{
DWORD dwSerial = 0;
GetVolumeInformationA(NULL, NULL, NULL, &dwSerial, NULL, NULL, NULL, NULL);
std::stringstream ss;
ss << dwSerial;
std::string num_str = ss.str();
return num_str;
}
void InitVolumeName()
{
DWORD disk = GetLogicalDrives();
for (int i=0; i<26; i++)
{
if (disk&(1<<i))
{
char str[] = "A-:\\";
str[0] += i;
GetVolumeInformationA(str, NULL, 0, &Volumeserial[i], 0, 0, 0, 0);
}
}
}
int main(int argc, char *argv[])
{
PCHAR lpRootPathName;
PCHAR requiredVolLabel;
CHAR lpVolumeNameBuffer[MAX_PATH+1];
CHAR lpFileSystemNameBuffer[MAX_PATH+1];
BOOL retVal;
if(argc < 3)
{
printf("usage: chkvol.exe <Root Path Name> <Required Volume Label>\n");
printf("example: chkvol.exe C:\\ WINXP\n");
return 1;
}
lpRootPathName = argv[1];
requiredVolLabel = argv[2];
retVal = GetVolumeInformationA(lpRootPathName,
lpVolumeNameBuffer,
sizeof(lpVolumeNameBuffer),
NULL,
NULL,
NULL,
lpFileSystemNameBuffer,
sizeof(lpFileSystemNameBuffer)
);
if(retVal == 0)
{
printf("GetVolumeInformation failed with error %i\n", GetLastError());
return 2;
}
else
{
printf("GetVolumeInformation succeeded\n");
printf("Volume label for '%s' is '%s'\n", lpRootPathName, lpVolumeNameBuffer);
}
if(StrCmpIA(requiredVolLabel, lpVolumeNameBuffer) != 0 )
{
printf("Volume label is NOT equial to '%s'. Return code is 3\n", requiredVolLabel);
return 3;
}
else
{
printf("Volume label is equial to '%s'. Return code is 0\n", requiredVolLabel);
return 0;
}
}
ZString TranslateElementName(const ZString& strDevice)
{
if (strDevice.Find(':') != -1)
{
return strDevice;
}
else
{
// get a list of all of the drives on the system
char cTemp;
int nDrivesStringLength = GetLogicalDriveStringsA(1, &cTemp);
if (nDrivesStringLength == 0)
{
ZError("Error getting drives list\n");
return strDevice;
}
char* cbDrives = (char*)_alloca(nDrivesStringLength);
nDrivesStringLength = GetLogicalDriveStringsA(nDrivesStringLength, cbDrives);
if (nDrivesStringLength == 0)
{
ZError("Error getting drives list\n");
return strDevice;
}
// search through the list of drives looking for a CD-ROM who's volume
// label matches strDevice
while (cbDrives[0] != '\0')
{
const int c_nVolumeNameLength = 1024;
char cbVolumeName[c_nVolumeNameLength];
if (GetDriveTypeA(cbDrives) == DRIVE_CDROM
&& GetVolumeInformationA(cbDrives, cbVolumeName,
c_nVolumeNameLength, NULL, NULL, NULL, NULL, 0))
{
if (_stricmp(strDevice, cbVolumeName) == 0)
{
return cbDrives;
}
}
cbDrives += strlen(cbDrives) + 1;
}
return strDevice;
}
}
// [tom, 7/12/2005] Rather then converting this to unicode, just using the ANSI
// versions of the Win32 API as its quicker for testing.
bool Platform::cdFileExists(const char *filePath, const char *volumeName, S32 serialNum)
{
if (!filePath || !filePath[0])
return true;
//first find the CD device...
char fileBuf[1024];
char drivesBuf[256];
S32 length = GetLogicalDriveStringsA(256, drivesBuf);
char *drivePtr = drivesBuf;
while (S32(drivePtr - drivesBuf) < length)
{
char driveVolume[256], driveFileSystem[256];
U32 driveSerial, driveFNLength, driveFlags;
if ((dStricmp(drivePtr, "A:\\") != 0 && dStricmp(drivePtr, "B:\\") != 0) &&
GetVolumeInformationA((const char*)drivePtr, &driveVolume[0], (unsigned long)255,
(unsigned long*)&driveSerial, (unsigned long*)&driveFNLength,
(unsigned long*)&driveFlags, &driveFileSystem[0], (unsigned long)255))
{
#if defined (TORQUE_DEBUG) || !defined (TORQUE_SHIPPING)
Con::printf("Found Drive: %s, vol: %s, serial: %d", drivePtr, driveVolume, driveSerial);
#endif
//see if the volume and serial number match
if (!dStricmp(volumeName, driveVolume) && (!serialNum || (serialNum == driveSerial)))
{
//see if the file exists on this volume
if(dStrlen(drivePtr) == 3 && drivePtr[2] == '\\' && filePath[0] == '\\')
dSprintf(fileBuf, sizeof(fileBuf), "%s%s", drivePtr, filePath + 1);
else
dSprintf(fileBuf, sizeof(fileBuf), "%s%s", drivePtr, filePath);
#if defined (TORQUE_DEBUG) || !defined (TORQUE_SHIPPING)
Con::printf("Looking for file: %s on %s", fileBuf, driveVolume);
#endif
WIN32_FIND_DATAA findData;
HANDLE h = FindFirstFileA(fileBuf, &findData);
if(h != INVALID_HANDLE_VALUE)
{
FindClose(h);
return true;
}
FindClose(h);
}
}
//check the next drive
drivePtr += dStrlen(drivePtr) + 1;
}
return false;
}
std::string MachineInfo::GetBotID()
{
DWORD disk_serialINT;
GetVolumeInformationA(NULL, NULL, NULL, &disk_serialINT, NULL, NULL, NULL, NULL);
std::string HDDserial = std::to_string(disk_serialINT);
std::string ComputerName = this->PC_Name, Username = this->Username;
std::string result = ComputerName;
result += Username;
result += HDDserial;
return sha256(result);
}
void getHDDInfo( char *volumeSN, char *hwSN, char *fsName )
{
char szVolumeName[256] = {0};
char szFSName[256] = {0};
unsigned long dwVolumeSN = 0, dwMaxComponentLen = 0, dwFSFlags = 0;
if( !GetVolumeInformationA( "C:\\", szVolumeName, 256, &dwVolumeSN,
&dwMaxComponentLen, &dwFSFlags, szFSName, 256 ) ) return;
unsigned char MBR[512];
memset( MBR, 0, sizeof(MBR) );
read_MBR( MBR );
partial_boot_sector_info pbsi[max_pbsi] =
{
{"FAT32", 0x52, 0x43},
{"FAT", 0x36, 0x27},
{"NTFS", 0x03, 0x48}
};
// try to search for a valid boot sector
int i = 0;
for( i=0; i<max_pbsi; i++)
{
//char to_cmp[12];
//strncpy( to_cmp, (const char *)(MBR + pbsi[i].FsOffs), 3 );
//to_cmp[3] = 0;
//printf( "Cmp %d: [%s]==[%s]...\n", i, pbsi[i].Fs, to_cmp );
if( strncmp( pbsi[i].Fs, (const char *)(MBR + pbsi[i].FsOffs), strlen( pbsi[i].Fs ) ) == 0 )
{
// we found a valid signature
//printf( "found FS: %s; index %d\n", pbsi[i].Fs, i );
break;
}
}
if( i >= max_pbsi )
{
log_error( LOG_ERROR, "ERROR: Cannot get serial number of this file system!\n" );
return;
}
DWORD dwHWSN = 0;
memcpy( (void *)(&dwHWSN), (const void *)(MBR + pbsi[i].SerialOffs), sizeof(dwHWSN) );
// out data
sprintf( volumeSN, "%08X", dwVolumeSN );
sprintf( hwSN, "%08X", dwHWSN );
strcpy( fsName, szFSName );
}
int
TclpListVolumes(
Tcl_Interp *interp) /* Interpreter for returning volume list. */
{
Tcl_Obj *resultPtr, *elemPtr;
char buf[40 * 4]; /* There couldn't be more than 30 drives??? */
int i;
char *p;
resultPtr = Tcl_GetObjResult(interp);
/*
* On Win32s:
* GetLogicalDriveStrings() isn't implemented.
* GetLogicalDrives() returns incorrect information.
*/
if (GetLogicalDriveStringsA(sizeof(buf), buf) == 0) {
/*
* GetVolumeInformation() will detects all drives, but causes
* chattering on empty floppy drives. We only do this if
* GetLogicalDriveStrings() didn't work. It has also been reported
* that on some laptops it takes a while for GetVolumeInformation()
* to return when pinging an empty floppy drive, another reason to
* try to avoid calling it.
*/
buf[1] = ':';
buf[2] = '/';
buf[3] = '\0';
for (i = 0; i < 26; i++) {
buf[0] = (char) ('a' + i);
if (GetVolumeInformationA(buf, NULL, 0, NULL, NULL, NULL, NULL, 0)
|| (GetLastError() == ERROR_NOT_READY)) {
elemPtr = Tcl_NewStringObj(buf, -1);
Tcl_ListObjAppendElement(NULL, resultPtr, elemPtr);
}
}
} else {
for (p = buf; *p != '\0'; p += 4) {
p[2] = '/';
elemPtr = Tcl_NewStringObj(p, -1);
Tcl_ListObjAppendElement(NULL, resultPtr, elemPtr);
}
}
return TCL_OK;
}
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 = GetVolumeInformationA(drive, NULL, 0, NULL, NULL, &tmp, NULL, 0);
/* Revert back to old windows error handler */
SetErrorMode(oldErrorMode);
return(retval);
} /* mediaInDrive */
bool IsUnwatchableFS(const char *path) {
char volumeName[MAX_PATH];
char fsName[MAX_PATH];
DWORD fsFlags;
DWORD maxComponentLength;
SetErrorMode(SEM_FAILCRITICALERRORS);
if (!GetVolumeInformationA(path, volumeName, MAX_PATH - 1, NULL, &maxComponentLength, &fsFlags, fsName, MAX_PATH - 1))
return false;
if (strcmp(fsName, "NTFS") && strcmp(fsName, "FAT") && strcmp(fsName, "FAT32") && _stricmp(fsName, "exFAT") && _stricmp(fsName, "reFS"))
return true;
if (!strcmp(fsName, "NTFS") && maxComponentLength != 255 && !(fsFlags & FILE_SUPPORTS_REPARSE_POINTS)) {
// SAMBA reports itself as NTFS
return true;
}
return false;
}
VDStringW VDGetRootVolumeLabel(const wchar_t *rootPath) {
union {
char a[MAX_PATH * 2];
wchar_t w[MAX_PATH];
} buf;
DWORD maxComponentLength;
DWORD fsFlags;
VDStringW name;
if (VDIsWindowsNT()) {
if (GetVolumeInformationW(rootPath, buf.w, vdcountof(buf.w), NULL, &maxComponentLength, &fsFlags, NULL, 0))
name = buf.w;
} else {
if (GetVolumeInformationA(VDTextWToA(rootPath).c_str(), buf.a, vdcountof(buf.a), NULL, &maxComponentLength, &fsFlags, NULL, 0))
name = VDTextAToW(buf.a);
}
return name;
}
static DWORD pollDiscDrives(void)
{
/* Try to use SetThreadErrorMode(), which showed up in Windows 7. */
HANDLE lib = LoadLibraryA("kernel32.dll");
fnSTEM stem = NULL;
char drive[4] = { 'x', ':', '\\', '\0' };
DWORD oldErrorMode = 0;
DWORD drives = 0;
DWORD i;
if (lib)
stem = (fnSTEM) GetProcAddress(lib, "SetThreadErrorMode");
if (stem)
stem(SEM_FAILCRITICALERRORS, &oldErrorMode);
else
oldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
/* Do detection. This may block if a disc is spinning up. */
for (i = 'A'; i <= 'Z'; i++)
{
DWORD tmp = 0;
drive[0] = (char) i;
if (GetDriveTypeA(drive) != DRIVE_CDROM)
continue;
/* If this function succeeds, there's media in the drive */
if (GetVolumeInformationA(drive, NULL, 0, NULL, NULL, &tmp, NULL, 0))
drives |= (1 << (i - 'A'));
} /* for */
if (stem)
stem(oldErrorMode, NULL);
else
SetErrorMode(oldErrorMode);
if (lib)
FreeLibrary(lib);
return drives;
} /* pollDiscDrives */
static int
TestvolumetypeCmd(
ClientData clientData, /* Not used. */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument objects. */
{
#define VOL_BUF_SIZE 32
int found;
char volType[VOL_BUF_SIZE];
char *path;
if (objc > 2) {
Tcl_WrongNumArgs(interp, 1, objv, "?name?");
return TCL_ERROR;
}
if (objc == 2) {
/*
* path has to be really a proper volume, but we don't get query APIs
* for that until NT5
*/
path = Tcl_GetString(objv[1]);
} else {
path = NULL;
}
found = GetVolumeInformationA(path, NULL, 0, NULL, NULL, NULL, volType,
VOL_BUF_SIZE);
if (found == 0) {
Tcl_AppendResult(interp, "could not get volume type for \"",
(path?path:""), "\"", NULL);
TclWinConvertError(GetLastError());
return TCL_ERROR;
}
Tcl_SetResult(interp, volType, TCL_VOLATILE);
return TCL_OK;
#undef VOL_BUF_SIZE
}
bool PrintMountPointsForVolume(HANDLE hVol, const char *volumePath, char *Buf) {
HANDLE hPt; // handle for mount point scan
char Path[BUFSIZE]; // string buffer for mount points
DWORD dwSysFlags; // flags that describe the file system
char FileSysNameBuf[BUFSIZE];
// Is this volume NTFS?
GetVolumeInformationA(Buf, NULL, 0, NULL, NULL, &dwSysFlags, FileSysNameBuf, BUFSIZE);
// Detect support for reparse points, and therefore for volume
// mount points, which are implemented using reparse points.
if (!(dwSysFlags & FILE_SUPPORTS_REPARSE_POINTS)) {
return true;
}
// Start processing mount points on this volume.
hPt = FindFirstVolumeMountPointA(
Buf, // root path of volume to be scanned
Path, // pointer to output string
BUFSIZE // size of output buffer
);
// Shall we error out?
if (hPt == INVALID_HANDLE_VALUE) {
return GetLastError() != ERROR_ACCESS_DENIED;
}
// Process the volume mount point.
char *buf = new char[MAX_PATH];
do {
strcpy_s(buf, MAX_PATH, volumePath);
strcat_s(buf, MAX_PATH, Path);
PrintDirectoryReparsePoint(buf);
} while (FindNextVolumeMountPointA(hPt, Path, BUFSIZE));
FindVolumeMountPointClose(hPt);
return true;
}
/*
* Fill the drive properties (size, FS, etc)
* Returns TRUE if the drive has a partition that can be mounted in Windows, FALSE otherwise
*/
BOOL GetDrivePartitionData(DWORD DriveIndex, char* FileSystemName, DWORD FileSystemNameSize, BOOL bSilent)
{
// MBR partition types that can be mounted in Windows
const uint8_t mbr_mountable[] = { 0x01, 0x04, 0x06, 0x07, 0x0b, 0x0c, 0x0e, 0xef };
BOOL r, ret = FALSE, isUefiNtfs = FALSE;
HANDLE hPhysical;
DWORD size;
BYTE geometry[256] = {0}, layout[4096] = {0}, part_type;
PDISK_GEOMETRY_EX DiskGeometry = (PDISK_GEOMETRY_EX)(void*)geometry;
PDRIVE_LAYOUT_INFORMATION_EX DriveLayout = (PDRIVE_LAYOUT_INFORMATION_EX)(void*)layout;
char* volume_name;
char tmp[256];
DWORD i, j;
if (FileSystemName == NULL)
return FALSE;
SelectedDrive.nPartitions = 0;
// Populate the filesystem data
FileSystemName[0] = 0;
volume_name = GetLogicalName(DriveIndex, TRUE, FALSE);
if ((volume_name == NULL) || (!GetVolumeInformationA(volume_name, NULL, 0, NULL, NULL, NULL, FileSystemName, FileSystemNameSize))) {
suprintf("No volume information for drive 0x%02x\n", DriveIndex);
}
safe_free(volume_name);
hPhysical = GetPhysicalHandle(DriveIndex, FALSE, FALSE);
if (hPhysical == INVALID_HANDLE_VALUE)
return 0;
r = DeviceIoControl(hPhysical, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
NULL, 0, geometry, sizeof(geometry), &size, NULL);
if (!r || size <= 0) {
suprintf("Could not get geometry for drive 0x%02x: %s\n", DriveIndex, WindowsErrorString());
safe_closehandle(hPhysical);
return 0;
}
if (DiskGeometry->Geometry.BytesPerSector < 512) {
suprintf("Warning: Drive 0x%02x reports a sector size of %d - Correcting to 512 bytes.\n",
DriveIndex, DiskGeometry->Geometry.BytesPerSector);
DiskGeometry->Geometry.BytesPerSector = 512;
}
SelectedDrive.DiskSize = DiskGeometry->DiskSize.QuadPart;
memcpy(&SelectedDrive.Geometry, &DiskGeometry->Geometry, sizeof(DISK_GEOMETRY));
suprintf("Disk type: %s, Sector Size: %d bytes\n", (DiskGeometry->Geometry.MediaType == FixedMedia)?"Fixed":"Removable",
DiskGeometry->Geometry.BytesPerSector);
suprintf("Cylinders: %" PRIi64 ", TracksPerCylinder: %d, SectorsPerTrack: %d\n",
DiskGeometry->Geometry.Cylinders, DiskGeometry->Geometry.TracksPerCylinder, DiskGeometry->Geometry.SectorsPerTrack);
r = DeviceIoControl(hPhysical, IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
NULL, 0, layout, sizeof(layout), &size, NULL );
if (!r || size <= 0) {
suprintf("Could not get layout for drive 0x%02x: %s\n", DriveIndex, WindowsErrorString());
safe_closehandle(hPhysical);
return 0;
}
#if defined(__GNUC__)
// GCC 4.9 bugs us about the fact that MS defined an expandable array as array[1]
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
switch (DriveLayout->PartitionStyle) {
case PARTITION_STYLE_MBR:
SelectedDrive.PartitionType = PARTITION_STYLE_MBR;
for (i=0; i<DriveLayout->PartitionCount; i++) {
if (DriveLayout->PartitionEntry[i].Mbr.PartitionType != PARTITION_ENTRY_UNUSED) {
SelectedDrive.nPartitions++;
}
}
suprintf("Partition type: MBR, NB Partitions: %d\n", SelectedDrive.nPartitions);
SelectedDrive.has_mbr_uefi_marker = (DriveLayout->Mbr.Signature == MBR_UEFI_MARKER);
suprintf("Disk ID: 0x%08X %s\n", DriveLayout->Mbr.Signature, SelectedDrive.has_mbr_uefi_marker?"(UEFI target)":"");
AnalyzeMBR(hPhysical, "Drive");
for (i=0; i<DriveLayout->PartitionCount; i++) {
if (DriveLayout->PartitionEntry[i].Mbr.PartitionType != PARTITION_ENTRY_UNUSED) {
part_type = DriveLayout->PartitionEntry[i].Mbr.PartitionType;
isUefiNtfs = (i == 1) && (part_type == 0xef) &&
(DriveLayout->PartitionEntry[i].PartitionLength.QuadPart <= 1*MB);
suprintf("Partition %d%s:\n", i+1, isUefiNtfs?" (UEFI:NTFS)":"");
for (j=0; j<ARRAYSIZE(mbr_mountable); j++) {
if (part_type == mbr_mountable[j]) {
ret = TRUE;
break;
}
}
// NB: MinGW's gcc 4.9.2 broke "%lld" printout on XP so we use the inttypes.h "PRI##" qualifiers
suprintf(" Type: %s (0x%02x)\r\n Size: %s (%" PRIi64 " bytes)\r\n Start Sector: %d, Boot: %s, Recognized: %s\n",
((part_type==0x07)&&(FileSystemName[0]!=0))?FileSystemName:GetPartitionType(part_type), part_type,
SizeToHumanReadable(DriveLayout->PartitionEntry[i].PartitionLength.QuadPart, TRUE, FALSE),
DriveLayout->PartitionEntry[i].PartitionLength.QuadPart, DriveLayout->PartitionEntry[i].Mbr.HiddenSectors,
DriveLayout->PartitionEntry[i].Mbr.BootIndicator?"Yes":"No",
DriveLayout->PartitionEntry[i].Mbr.RecognizedPartition?"Yes":"No");
if ((part_type == RUFUS_EXTRA_PARTITION_TYPE) || (isUefiNtfs))
// This is a partition Rufus created => we can safely ignore it
--SelectedDrive.nPartitions;
if (part_type == 0xee) // Flag a protective MBR for non GPT platforms (XP)
SelectedDrive.has_protective_mbr = TRUE;
}
}
break;
case PARTITION_STYLE_GPT:
SelectedDrive.PartitionType = PARTITION_STYLE_GPT;
suprintf("Partition type: GPT, NB Partitions: %d\n", DriveLayout->PartitionCount);
suprintf("Disk GUID: %s\n", GuidToString(&DriveLayout->Gpt.DiskId));
suprintf("Max parts: %d, Start Offset: %" PRIi64 ", Usable = %" PRIi64 " bytes\n",
DriveLayout->Gpt.MaxPartitionCount, DriveLayout->Gpt.StartingUsableOffset.QuadPart, DriveLayout->Gpt.UsableLength.QuadPart);
for (i=0; i<DriveLayout->PartitionCount; i++) {
SelectedDrive.nPartitions++;
tmp[0] = 0;
wchar_to_utf8_no_alloc(DriveLayout->PartitionEntry[i].Gpt.Name, tmp, sizeof(tmp));
suprintf("Partition %d:\r\n Type: %s\r\n Name: '%s'\n", i+1,
GuidToString(&DriveLayout->PartitionEntry[i].Gpt.PartitionType), tmp);
suprintf(" ID: %s\r\n Size: %s (%" PRIi64 " bytes)\r\n Start Sector: %" PRIi64 ", Attributes: 0x%016" PRIX64 "\n",
GuidToString(&DriveLayout->PartitionEntry[i].Gpt.PartitionId), SizeToHumanReadable(DriveLayout->PartitionEntry[i].PartitionLength.QuadPart, TRUE, FALSE),
DriveLayout->PartitionEntry[i].PartitionLength, DriveLayout->PartitionEntry[i].StartingOffset.QuadPart / DiskGeometry->Geometry.BytesPerSector,
DriveLayout->PartitionEntry[i].Gpt.Attributes);
// Don't register the partitions that we don't care about destroying
if ( (strcmp(tmp, "UEFI:NTFS") == 0) ||
(CompareGUID(&DriveLayout->PartitionEntry[i].Gpt.PartitionType, &PARTITION_MSFT_RESERVED_GUID)) ||
(CompareGUID(&DriveLayout->PartitionEntry[i].Gpt.PartitionType, &PARTITION_SYSTEM_GUID)) )
--SelectedDrive.nPartitions;
if ( (memcmp(&PARTITION_BASIC_DATA_GUID, &DriveLayout->PartitionEntry[i].Gpt.PartitionType, sizeof(GUID)) == 0) &&
(nWindowsVersion >= WINDOWS_VISTA) )
ret = TRUE;
}
break;
default:
SelectedDrive.PartitionType = PARTITION_STYLE_MBR;
suprintf("Partition type: RAW\n");
break;
}
#if defined(__GNUC__)
#pragma GCC diagnostic warning "-Warray-bounds"
#endif
safe_closehandle(hPhysical);
return ret;
}
BOOL GetVolumeCaps(
char *rootpath, /* filepath, or NULL */
char *name, /* filename associated with rootpath */
PVOLUMECAPS VolumeCaps /* result structure describing capabilities */
)
{
char TempRootPath[MAX_PATH + 1];
DWORD cchTempRootPath = 0;
BOOL bSuccess = TRUE; /* assume success until told otherwise */
if(!bInitialized) if(!Initialize()) return FALSE;
/* process the input path to produce a consistent path suitable for
compare operations and also suitable for certain picky Win32 API
that don't like forward slashes */
if(rootpath != NULL && rootpath[0] != '\0') {
DWORD i;
cchTempRootPath = lstrlenA(rootpath);
if(cchTempRootPath > MAX_PATH) return FALSE;
/* copy input, converting forward slashes to back slashes as we go */
for(i = 0 ; i <= cchTempRootPath ; i++) {
if(rootpath[i] == '/') TempRootPath[i] = '\\';
else TempRootPath[i] = rootpath[i];
}
/* check for UNC and Null terminate or append trailing \ as
appropriate */
/* possible valid UNCs we are passed follow:
\\machine\foo\bar (path is \\machine\foo\)
\\machine\foo (path is \\machine\foo\)
\\machine\foo\
\\.\c$\ (FIXFIX: Win32API doesn't like this - GetComputerName())
LATERLATER: handling mounted DFS drives in the future will require
slightly different logic which isn't available today.
This is required because directories can point at
different servers which have differing capabilities.
*/
if(TempRootPath[0] == '\\' && TempRootPath[1] == '\\') {
DWORD slash = 0;
for(i = 2 ; i < cchTempRootPath ; i++) {
if(TempRootPath[i] == '\\') {
slash++;
if(slash == 2) {
i++;
TempRootPath[i] = '\0';
cchTempRootPath = i;
break;
}
}
}
/* if there was only one slash found, just tack another onto the
end */
if(slash == 1 && TempRootPath[cchTempRootPath] != '\\') {
TempRootPath[cchTempRootPath] = TempRootPath[0]; /* '\\' */
TempRootPath[cchTempRootPath+1] = '\0';
cchTempRootPath++;
}
} else {
if(TempRootPath[1] == ':') {
/* drive letter specified, truncate to root */
TempRootPath[2] = '\\';
TempRootPath[3] = '\0';
cchTempRootPath = 3;
} else {
/* must be file on current drive */
TempRootPath[0] = '\0';
cchTempRootPath = 0;
}
}
} /* if path != NULL */
/* grab lock protecting cached entry */
EnterCriticalSection( &VolumeCapsLock );
if(!g_VolumeCaps.bValid ||
lstrcmpiA(g_VolumeCaps.RootPath, TempRootPath) != 0)
{
/* no match found, build up new entry */
DWORD dwFileSystemFlags;
DWORD dwRemotePrivileges = 0;
BOOL bRemote = FALSE;
/* release lock during expensive operations */
LeaveCriticalSection( &VolumeCapsLock );
bSuccess = GetVolumeInformationA(
(TempRootPath[0] == '\0') ? NULL : TempRootPath,
NULL, 0,
NULL, NULL,
&dwFileSystemFlags,
NULL, 0);
/* only if target volume supports Acls, and we were told to use
privileges do we need to go out and test for the remote case */
if(bSuccess && (dwFileSystemFlags & FS_PERSISTENT_ACLS) &&
VolumeCaps->bUsePrivileges)
{
if(GetDriveTypeA( (TempRootPath[0] == '\0') ? NULL : TempRootPath )
== DRIVE_REMOTE)
{
bRemote = TRUE;
/* make a determination about our remote capabilities */
GetRemotePrivilegesSet(name, &dwRemotePrivileges);
}
}
/* always take the lock again, since we release it below */
EnterCriticalSection( &VolumeCapsLock );
/* replace the existing data if successful */
if(bSuccess) {
lstrcpynA(g_VolumeCaps.RootPath, TempRootPath, cchTempRootPath+1);
g_VolumeCaps.dwFileSystemFlags = dwFileSystemFlags;
g_VolumeCaps.bRemote = bRemote;
g_VolumeCaps.dwRemotePrivileges = dwRemotePrivileges;
g_VolumeCaps.bValid = TRUE;
}
}
if(bSuccess) {
/* copy input elements */
g_VolumeCaps.bUsePrivileges = VolumeCaps->bUsePrivileges;
g_VolumeCaps.dwFileAttributes = VolumeCaps->dwFileAttributes;
/* give caller results */
memcpy(VolumeCaps, &g_VolumeCaps, sizeof(VOLUMECAPS));
} else {
g_VolumeCaps.bValid = FALSE;
}
LeaveCriticalSection( &VolumeCapsLock ); /* release lock */
return bSuccess;
}
int enumerate_devices(device_callback_t callback, void *userdata, int dc_type)
{
int index = -1;
DWORD i;
if (dc_type != DC_TYPE_UEMIS) {
// Open the registry key.
HKEY hKey;
LONG rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\SERIALCOMM", 0, KEY_QUERY_VALUE, &hKey);
if (rc != ERROR_SUCCESS) {
return -1;
}
// Get the number of values.
DWORD count = 0;
rc = RegQueryInfoKey(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL);
if (rc != ERROR_SUCCESS) {
RegCloseKey(hKey);
return -1;
}
for (i = 0; i < count; ++i) {
// Get the value name, data and type.
char name[512], data[512];
DWORD name_len = sizeof(name);
DWORD data_len = sizeof(data);
DWORD type = 0;
rc = RegEnumValue(hKey, i, name, &name_len, NULL, &type, (LPBYTE)data, &data_len);
if (rc != ERROR_SUCCESS) {
RegCloseKey(hKey);
return -1;
}
// Ignore non-string values.
if (type != REG_SZ)
continue;
// Prevent a possible buffer overflow.
if (data_len >= sizeof(data)) {
RegCloseKey(hKey);
return -1;
}
// Null terminate the string.
data[data_len] = 0;
callback(data, userdata);
index++;
if (is_default_dive_computer_device(name))
index = i;
}
RegCloseKey(hKey);
}
if (dc_type != DC_TYPE_SERIAL) {
int i;
int count_drives = 0;
const int bufdef = 512;
const char *dlabels[] = {"UEMISSDA", NULL};
char bufname[bufdef], bufval[bufdef], *p;
DWORD bufname_len;
/* add drive letters that match labels */
memset(bufname, 0, bufdef);
bufname_len = bufdef;
if (GetLogicalDriveStringsA(bufname_len, bufname)) {
p = bufname;
while (*p) {
memset(bufval, 0, bufdef);
if (GetVolumeInformationA(p, bufval, bufdef, NULL, NULL, NULL, NULL, 0)) {
for (i = 0; dlabels[i] != NULL; i++)
if (!strcmp(bufval, dlabels[i])) {
char data[512];
snprintf(data, sizeof(data), "%s (%s)", p, dlabels[i]);
callback(data, userdata);
if (is_default_dive_computer_device(p))
index = count_drives;
count_drives++;
}
}
p = &p[strlen(p) + 1];
}
if (count_drives == 1) /* we found exactly one Uemis "drive" */
index = 0; /* make it the selected "device" */
}
}
return index;
}
/*
* Fill the drive properties (size, FS, etc)
*/
int GetDrivePartitionData(DWORD DriveIndex, char* FileSystemName, DWORD FileSystemNameSize)
{
BOOL r, hasRufusExtra = FALSE;
HANDLE hPhysical;
DWORD size;
BYTE geometry[256], layout[4096], part_type;
PDISK_GEOMETRY_EX DiskGeometry = (PDISK_GEOMETRY_EX)(void*)geometry;
PDRIVE_LAYOUT_INFORMATION_EX DriveLayout = (PDRIVE_LAYOUT_INFORMATION_EX)(void*)layout;
char* volume_name;
char tmp[256];
DWORD i, nb_partitions = 0;
// Populate the filesystem data
FileSystemName[0] = 0;
volume_name = GetLogicalName(DriveIndex, TRUE, FALSE);
if ((volume_name == NULL) || (!GetVolumeInformationA(volume_name, NULL, 0, NULL, NULL, NULL, FileSystemName, FileSystemNameSize))) {
uprintf("No volume information for disk 0x%02x\n", DriveIndex);
}
safe_free(volume_name);
hPhysical = GetPhysicalHandle(DriveIndex, FALSE, FALSE);
if (hPhysical == INVALID_HANDLE_VALUE)
return 0;
r = DeviceIoControl(hPhysical, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
NULL, 0, geometry, sizeof(geometry), &size, NULL);
if (!r || size <= 0) {
uprintf("Could not get geometry for drive 0x%02x: %s\n", DriveIndex, WindowsErrorString());
safe_closehandle(hPhysical);
return 0;
}
SelectedDrive.DiskSize = DiskGeometry->DiskSize.QuadPart;
memcpy(&SelectedDrive.Geometry, &DiskGeometry->Geometry, sizeof(DISK_GEOMETRY));
uprintf("Disk type: %s, Sector Size: %d bytes\n", (DiskGeometry->Geometry.MediaType == FixedMedia)?"Fixed":"Removable",
DiskGeometry->Geometry.BytesPerSector);
uprintf("Cylinders: %lld, TracksPerCylinder: %d, SectorsPerTrack: %d\n",
DiskGeometry->Geometry.Cylinders, DiskGeometry->Geometry.TracksPerCylinder, DiskGeometry->Geometry.SectorsPerTrack);
r = DeviceIoControl(hPhysical, IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
NULL, 0, layout, sizeof(layout), &size, NULL );
if (!r || size <= 0) {
uprintf("Could not get layout for drive 0x%02x: %s\n", DriveIndex, WindowsErrorString());
safe_closehandle(hPhysical);
return 0;
}
switch (DriveLayout->PartitionStyle) {
case PARTITION_STYLE_MBR:
SelectedDrive.PartitionType = PARTITION_STYLE_MBR;
for (i=0; i<DriveLayout->PartitionCount; i++) {
if (DriveLayout->PartitionEntry[i].Mbr.PartitionType != PARTITION_ENTRY_UNUSED) {
nb_partitions++;
}
}
uprintf("Partition type: MBR, NB Partitions: %d\n", nb_partitions);
SelectedDrive.has_mbr_uefi_marker = (DriveLayout->Mbr.Signature == MBR_UEFI_MARKER);
uprintf("Disk ID: 0x%08X %s\n", DriveLayout->Mbr.Signature, SelectedDrive.has_mbr_uefi_marker?"(UEFI target)":"");
AnalyzeMBR(hPhysical, "Drive");
for (i=0; i<DriveLayout->PartitionCount; i++) {
if (DriveLayout->PartitionEntry[i].Mbr.PartitionType != PARTITION_ENTRY_UNUSED) {
uprintf("Partition %d:\n", i+1);
part_type = DriveLayout->PartitionEntry[i].Mbr.PartitionType;
uprintf(" Type: %s (0x%02x)\r\n Size: %s (%lld bytes)\r\n Start Sector: %d, Boot: %s, Recognized: %s\n",
((part_type==0x07)&&(FileSystemName[0]!=0))?FileSystemName:GetPartitionType(part_type), part_type,
SizeToHumanReadable(DriveLayout->PartitionEntry[i].PartitionLength.QuadPart, TRUE, FALSE),
DriveLayout->PartitionEntry[i].PartitionLength, DriveLayout->PartitionEntry[i].Mbr.HiddenSectors,
DriveLayout->PartitionEntry[i].Mbr.BootIndicator?"Yes":"No",
DriveLayout->PartitionEntry[i].Mbr.RecognizedPartition?"Yes":"No");
if (part_type == RUFUS_EXTRA_PARTITION_TYPE) // This is a partition Rufus created => we can safely ignore it
hasRufusExtra = TRUE;
if (part_type == 0xee) // Flag a protective MBR for non GPT platforms (XP)
SelectedDrive.has_protective_mbr = TRUE;
}
}
break;
case PARTITION_STYLE_GPT:
SelectedDrive.PartitionType = PARTITION_STYLE_GPT;
uprintf("Partition type: GPT, NB Partitions: %d\n", DriveLayout->PartitionCount);
uprintf("Disk GUID: %s\n", GuidToString(&DriveLayout->Gpt.DiskId));
uprintf("Max parts: %d, Start Offset: %lld, Usable = %lld bytes\n",
DriveLayout->Gpt.MaxPartitionCount, DriveLayout->Gpt.StartingUsableOffset.QuadPart, DriveLayout->Gpt.UsableLength.QuadPart);
for (i=0; i<DriveLayout->PartitionCount; i++) {
nb_partitions++;
tmp[0] = 0;
wchar_to_utf8_no_alloc(DriveLayout->PartitionEntry[i].Gpt.Name, tmp, sizeof(tmp));
uprintf("Partition %d:\r\n Type: %s\r\n Name: '%s'\n", DriveLayout->PartitionEntry[i].PartitionNumber,
GuidToString(&DriveLayout->PartitionEntry[i].Gpt.PartitionType), tmp);
uprintf(" ID: %s\r\n Size: %s (%lld bytes)\r\n Start Sector: %lld, Attributes: 0x%016llX\n",
GuidToString(&DriveLayout->PartitionEntry[i].Gpt.PartitionId), SizeToHumanReadable(DriveLayout->PartitionEntry[i].PartitionLength.QuadPart, TRUE, FALSE),
DriveLayout->PartitionEntry[i].PartitionLength, DriveLayout->PartitionEntry[i].StartingOffset.QuadPart / DiskGeometry->Geometry.BytesPerSector,
DriveLayout->PartitionEntry[i].Gpt.Attributes);
}
break;
default:
SelectedDrive.PartitionType = PARTITION_STYLE_MBR;
uprintf("Partition type: RAW\n");
break;
}
safe_closehandle(hPhysical);
if (hasRufusExtra)
nb_partitions--;
return (int)nb_partitions;
}
int subsurface_fill_device_list(GtkListStore *store)
{
const int bufdef = 512;
const char *dlabels[] = {"UEMISSDA", NULL};
const char *devdef = "COM1";
GtkTreeIter iter;
int index = -1, nentries = 0, ret, i;
char bufname[bufdef], bufval[bufdef], *p;
DWORD nvalues, bufval_len, bufname_len;
HKEY key;
/* add serial ports */
ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\SERIALCOMM",
0, KEY_READ, &key);
if (ret == ERROR_SUCCESS) {
ret = RegQueryInfoKeyA(key, NULL, NULL, NULL, NULL, NULL, NULL, &nvalues,
NULL, NULL, NULL, NULL);
if (ret == ERROR_SUCCESS)
for (i = 0; i < nvalues; i++) {
memset(bufval, 0, bufdef);
memset(bufname, 0, bufdef);
bufname_len = bufdef;
bufval_len = bufdef;
ret = RegEnumValueA(key, i, bufname, &bufname_len, NULL, NULL, bufval,
&bufval_len);
if (ret == ERROR_SUCCESS) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, bufval, -1);
if (is_default_dive_computer_device(bufval))
index = nentries;
nentries++;
}
}
}
/* add drive letters that match labels */
memset(bufname, 0, bufdef);
bufname_len = bufdef;
if (GetLogicalDriveStringsA(bufname_len, bufname)) {
p = bufname;
while (*p) {
memset(bufval, 0, bufdef);
if (GetVolumeInformationA(p, bufval, bufdef, NULL, NULL, NULL, NULL, 0)) {
for (i = 0; dlabels[i] != NULL; i++)
if (!strcmp(bufval, dlabels[i])) {
char name[80];
snprintf(name, sizeof(name), "%s (%s)", p, dlabels[i]);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, name, -1);
if (is_default_dive_computer_device(p))
index = nentries;
nentries++;
}
}
p = &p[strlen(p) + 1];
}
}
/* if we can't find anything, use the default */
if (!nentries) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, devdef, -1);
if (is_default_dive_computer_device(devdef))
index = 0;
}
return index;
}
sg_fs_stats *sg_get_fs_stats(int *entries){
VECTOR_DECLARE_STATIC(disk_stats, sg_fs_stats, 10,
disk_stat_init, disk_stat_destroy);
int num_disks=0;
#if defined(LINUX) || defined (SOLARIS) || defined(CYGWIN) || defined(HPUX)
FILE *f;
#endif
sg_fs_stats *disk_ptr;
#ifdef SOLARIS
struct mnttab mp;
struct statvfs fs;
#endif
#if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
struct mntent *mp;
struct statvfs fs;
#endif
#ifdef ALLBSD
int nummnt;
#ifdef HAVE_STATVFS
struct statvfs *mp, **fs;
#else
struct statfs *mp, **fs;
#endif
#endif
#ifdef WIN32
char lp_buf[MAX_PATH];
char volume_name_buf[BUFSIZE];
char filesys_name_buf[BUFSIZE];
char drive[4] = " :\\";
char *p;
int drive_type; //@
lp_buf[0]='\0';
#endif
#ifdef ALLBSD
nummnt=getmntinfo(&mp, MNT_WAIT);
if (nummnt<=0){
sg_set_error_with_errno(SG_ERROR_GETMNTINFO, NULL);
return NULL;
}
for(fs = ∓ nummnt--; (*fs)++){
#endif
#if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
#ifdef MNT_MNTTAB
if ((f=setmntent(MNT_MNTTAB, "r" ))==NULL){
#else
if ((f=setmntent("/etc/mtab", "r" ))==NULL){
#endif
sg_set_error(SG_ERROR_SETMNTENT, NULL);
return NULL;
}
while((mp=getmntent(f))){
if((statvfs(mp->mnt_dir, &fs)) !=0){
continue;
}
#endif
#ifdef SOLARIS
if ((f=fopen("/etc/mnttab", "r" ))==NULL){
sg_set_error_with_errno(SG_ERROR_OPEN, "/etc/mnttab");
return NULL;
}
while((getmntent(f, &mp)) == 0){
if ((statvfs(mp.mnt_mountp, &fs)) !=0){
continue;
}
#endif
#ifdef WIN32
if (!(GetLogicalDriveStringsA(BUFSIZE-1, lp_buf))) {
sg_set_error(SG_ERROR_GETMNTINFO, "GetLogicalDriveStrings");
return NULL;
}
p = lp_buf;
do {
// Copy drive letter to template string
*drive = *p;
// Only interested in harddrives.
drive_type = GetDriveTypeA(drive);
if(drive_type == DRIVE_FIXED) {
#else
if(is_valid_fs_type(SG_MP_FSTYPENAME(mp))){
#endif
if (VECTOR_RESIZE(disk_stats, num_disks + 1) < 0) {
return NULL;
}
disk_ptr=disk_stats+num_disks;
#ifndef WIN32
/* Maybe make this char[bigenough] and do strncpy's and put a null in the end?
* Downside is its a bit hungry for a lot of mounts, as MNT_MAX_SIZE would prob
* be upwards of a k each
*/
if (sg_update_string(&disk_ptr->device_name, SG_MP_DEVNAME(mp)) < 0) {
return NULL;
}
if (sg_update_string(&disk_ptr->fs_type, SG_MP_FSTYPENAME(mp)) < 0) {
return NULL;
}
if (sg_update_string(&disk_ptr->mnt_point, SG_MP_MOUNTP(mp)) < 0) {
return NULL;
}
disk_ptr->size = SG_FS_FRSIZE(fs) * SG_FS_BLOCKS(fs);
disk_ptr->avail = SG_FS_FRSIZE(fs) * SG_FS_BAVAIL(fs);
disk_ptr->used = (disk_ptr->size) - (SG_FS_FRSIZE(fs) * SG_FS_BFREE(fs));
disk_ptr->total_inodes = SG_FS_FILES(fs);
disk_ptr->free_inodes = SG_FS_FFREE(fs);
/* Linux, FreeBSD don't have a "available" inodes */
disk_ptr->used_inodes = disk_ptr->total_inodes - disk_ptr->free_inodes;
disk_ptr->avail_inodes = SG_FS_FAVAIL(fs);
disk_ptr->io_size = SG_FS_BSIZE(fs);
disk_ptr->block_size = SG_FS_FRSIZE(fs);
disk_ptr->total_blocks = SG_FS_BLOCKS(fs);
disk_ptr->free_blocks = SG_FS_BFREE(fs);
disk_ptr->avail_blocks = SG_FS_BAVAIL(fs);
disk_ptr->used_blocks = disk_ptr->total_blocks - disk_ptr->free_blocks;
#else
if(!GetVolumeInformationA(drive, volume_name_buf, BUFSIZE,
NULL, NULL, NULL,
filesys_name_buf, BUFSIZE)) {
sg_set_error_with_errno(SG_ERROR_DISKINFO,
"GetVolumeInformation");
return NULL;
}
if (sg_update_string(&disk_ptr->device_name,
volume_name_buf) < 0) {
return NULL;
}
if (sg_update_string(&disk_ptr->fs_type,
filesys_name_buf) < 0) {
return NULL;
}
if (sg_update_string(&disk_ptr->mnt_point,
drive) < 0) {
return NULL;
}
if (!GetDiskFreeSpaceExA(drive, NULL,
(PULARGE_INTEGER)&disk_ptr->size,
(PULARGE_INTEGER)&disk_ptr->avail)) {
sg_set_error_with_errno(SG_ERROR_DISKINFO,
"GetDiskFreeSpaceEx");
return NULL;
}
disk_ptr->used = disk_ptr->size - disk_ptr->avail;
disk_ptr->total_inodes = 0;
disk_ptr->free_inodes = 0;
disk_ptr->used_inodes = 0;
disk_ptr->avail_inodes = 0;
/* I dunno what to do with these... so have nothing */
disk_ptr->io_size = 0;
disk_ptr->block_size = 0;
disk_ptr->total_blocks = 0;
disk_ptr->free_blocks = 0;
disk_ptr->avail_blocks = 0;
disk_ptr->used_blocks = 0;
#endif
num_disks++;
}
#ifdef WIN32
while(*p++);
} while(*p);
#else
}
#endif
*entries=num_disks;
/* If this fails, there is very little i can do about it, so
I'll ignore it :) */
#if defined(LINUX) || defined(CYGWIN) || defined(HPUX)
endmntent(f);
#endif
#if defined(SOLARIS)
fclose(f);
#endif
return disk_stats;
}
int sg_fs_compare_device_name(const void *va, const void *vb) {
const sg_fs_stats *a = (const sg_fs_stats *)va;
const sg_fs_stats *b = (const sg_fs_stats *)vb;
return strcmp(a->device_name, b->device_name);
}
int sg_fs_compare_mnt_point(const void *va, const void *vb) {
const sg_fs_stats *a = (const sg_fs_stats *)va;
const sg_fs_stats *b = (const sg_fs_stats *)vb;
return strcmp(a->mnt_point, b->mnt_point);
}
static void diskio_stat_init(sg_disk_io_stats *d) {
d->disk_name = NULL;
}
static void diskio_stat_destroy(sg_disk_io_stats *d) {
free(d->disk_name);
}
VECTOR_DECLARE_STATIC(diskio_stats, sg_disk_io_stats, 10,
diskio_stat_init, diskio_stat_destroy);
#ifdef LINUX
typedef struct {
int major;
int minor;
} partition;
#endif
sg_disk_io_stats *sg_get_disk_io_stats(int *entries){
int num_diskio;
#ifndef LINUX
sg_disk_io_stats *diskio_stats_ptr;
#endif
#ifdef HPUX
long long rbytes = 0, wbytes = 0;
struct dirent *dinfo = NULL;
struct stat lstatinfo;
struct pst_diskinfo pstat_diskinfo[DISK_BATCH];
char fullpathbuf[1024] = {0};
dev_t diskid;
DIR *dh = NULL;
int diskidx = 0;
int num, i;
#endif
#ifdef SOLARIS
kstat_ctl_t *kc;
kstat_t *ksp;
kstat_io_t kios;
#endif
#ifdef LINUX
FILE *f;
char *line_ptr;
int major, minor;
int has_pp_stats = 1;
VECTOR_DECLARE_STATIC(parts, partition, 16, NULL, NULL);
int i, n;
time_t now;
const char *format;
static regex_t not_part_re, part_re;
static int re_compiled = 0;
#endif
#if defined(FREEBSD) || defined(DFBSD)
static struct statinfo stats;
static int stats_init = 0;
int counter;
struct device_selection *dev_sel = NULL;
int n_selected, n_selections;
long sel_gen;
struct devstat *dev_ptr;
#endif
#ifdef NETBSD
struct disk_sysctl *stats;
#endif
#ifdef OPENBSD
int diskcount;
char *disknames, *name, *bufpp;
char **dk_name;
struct diskstats *stats;
#endif
#ifdef NETBSD
#define MIBSIZE 3
#endif
#ifdef OPENBSD
#define MIBSIZE 2
#endif
#if defined(NETBSD) || defined(OPENBSD)
int num_disks, i;
int mib[MIBSIZE];
size_t size;
#endif
#ifdef WIN32
char *name;
long long rbytes;
long long wbytes;
#endif
num_diskio=0;
#ifdef HPUX
while (1) {
num = pstat_getdisk(pstat_diskinfo, sizeof pstat_diskinfo[0],
DISK_BATCH, diskidx);
if (num == -1) {
sg_set_error_with_errno(SG_ERROR_PSTAT,
"pstat_getdisk");
return NULL;
} else if (num == 0) {
break;
}
for (i = 0; i < num; i++) {
struct pst_diskinfo *di = &pstat_diskinfo[i];
/* Skip "disabled" disks. */
if (di->psd_status == 0) {
continue;
}
/* We can't seperate the reads from the writes, we'll
* just give the same to each. (This value is in
* 64-byte chunks according to the pstat header file,
* and can wrap to be negative.)
*/
rbytes = wbytes = ((unsigned long) di->psd_dkwds) * 64LL;
/* Skip unused disks. */
if (rbytes == 0 && wbytes == 0) {
continue;
}
if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
return NULL;
}
diskio_stats_ptr = diskio_stats + num_diskio;
diskio_stats_ptr->read_bytes = rbytes;
diskio_stats_ptr->write_bytes = wbytes;
diskio_stats_ptr->systime = time(NULL);
num_diskio++;
/* FIXME This should use a static cache, like the Linux
* code below. */
if (diskio_stats_ptr->disk_name == NULL) {
dh = opendir("/dev/dsk");
if (dh == NULL) {
continue;
}
diskid = (di->psd_dev.psd_major << 24) | di->psd_dev.psd_minor;
while (1) {
dinfo = readdir(dh);
if (dinfo == NULL) {
break;
}
snprintf(fullpathbuf, sizeof(fullpathbuf), "/dev/dsk/%s", dinfo->d_name);
if (lstat(fullpathbuf, &lstatinfo) < 0) {
continue;
}
if (lstatinfo.st_rdev == diskid) {
if (sg_update_string(&diskio_stats_ptr->disk_name, dinfo->d_name) < 0) {
return NULL;
}
break;
}
}
closedir(dh);
if (diskio_stats_ptr->disk_name == NULL) {
if (sg_update_string(&diskio_stats_ptr->disk_name, di->psd_hw_path.psh_name) < 0) {
return NULL;
}
}
}
}
diskidx = pstat_diskinfo[num - 1].psd_idx + 1;
}
#endif
#ifdef OPENBSD
mib[0] = CTL_HW;
mib[1] = HW_DISKCOUNT;
size = sizeof(diskcount);
if (sysctl(mib, MIBSIZE, &diskcount, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKCOUNT");
return NULL;
}
mib[0] = CTL_HW;
mib[1] = HW_DISKNAMES;
if (sysctl(mib, MIBSIZE, NULL, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKNAMES");
return NULL;
}
disknames = sg_malloc(size);
if (disknames == NULL) {
return NULL;
}
if (sysctl(mib, MIBSIZE, disknames, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKNAMES");
return NULL;
}
dk_name = sg_malloc(diskcount * sizeof(char *));
bufpp = disknames;
for (i = 0; i < diskcount && (name = strsep(&bufpp, ",")) != NULL; i++) {
dk_name[i] = name;
}
#endif
#if defined(NETBSD) || defined(OPENBSD)
mib[0] = CTL_HW;
mib[1] = HW_DISKSTATS;
#ifdef NETBSD
mib[2] = sizeof(struct disk_sysctl);
#endif
if (sysctl(mib, MIBSIZE, NULL, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKSTATS");
return NULL;
}
#ifdef NETBSD
num_disks = size / sizeof(struct disk_sysctl);
#else
num_disks = size / sizeof(struct diskstats);
#endif
stats = sg_malloc(size);
if (stats == NULL) {
return NULL;
}
if (sysctl(mib, MIBSIZE, stats, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_DISKSTATS");
return NULL;
}
for (i = 0; i < num_disks; i++) {
const char *name;
u_int64_t rbytes, wbytes;
#ifdef NETBSD
#ifdef HAVE_DK_RBYTES
rbytes = stats[i].dk_rbytes;
wbytes = stats[i].dk_wbytes;
#else
/* Before 2.0, NetBSD merged reads and writes. */
rbytes = wbytes = stats[i].dk_bytes;
#endif
#else
#ifdef HAVE_DS_RBYTES
rbytes = stats[i].ds_rbytes;
wbytes = stats[i].ds_wbytes;
#else
/* Before 3.5, OpenBSD merged reads and writes */
rbytes = wbytes = stats[i].ds_bytes;
#endif
#endif
/* Don't keep stats for disks that have never been used. */
if (rbytes == 0 && wbytes == 0) {
continue;
}
if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
return NULL;
}
diskio_stats_ptr = diskio_stats + num_diskio;
diskio_stats_ptr->read_bytes = rbytes;
diskio_stats_ptr->write_bytes = wbytes;
#ifdef NETBSD
name = stats[i].dk_name;
#else
name = dk_name[i];
#endif
if (sg_update_string(&diskio_stats_ptr->disk_name, name) < 0) {
return NULL;
}
diskio_stats_ptr->systime = time(NULL);
num_diskio++;
}
free(stats);
#ifdef OPENBSD
free(dk_name);
free(disknames);
#endif
#endif
#if defined(FREEBSD) || defined(DFBSD)
if (!stats_init) {
stats.dinfo=sg_malloc(sizeof(struct devinfo));
if(stats.dinfo==NULL) return NULL;
bzero(stats.dinfo, sizeof(struct devinfo));
stats_init = 1;
}
#ifdef FREEBSD5
if ((devstat_getdevs(NULL, &stats)) < 0) {
/* FIXME devstat functions return a string error in
devstat_errbuf */
sg_set_error(SG_ERROR_DEVSTAT_GETDEVS, NULL);
return NULL;
}
/* Not aware of a get all devices, so i said 999. If we ever
* find a machine with more than 999 disks, then i'll change
* this number :)
*/
if (devstat_selectdevs(&dev_sel, &n_selected, &n_selections, &sel_gen, stats.dinfo->generation, stats.dinfo->devices, stats.dinfo->numdevs, NULL, 0, NULL, 0, DS_SELECT_ONLY, 999, 1) < 0) {
sg_set_error(SG_ERROR_DEVSTAT_SELECTDEVS, NULL);
return NULL;
}
#else
if ((getdevs(&stats)) < 0) {
sg_set_error(SG_ERROR_DEVSTAT_GETDEVS, NULL);
return NULL;
}
/* Not aware of a get all devices, so i said 999. If we ever
* find a machine with more than 999 disks, then i'll change
* this number :)
*/
if (selectdevs(&dev_sel, &n_selected, &n_selections, &sel_gen, stats.dinfo->generation, stats.dinfo->devices, stats.dinfo->numdevs, NULL, 0, NULL, 0, DS_SELECT_ONLY, 999, 1) < 0) {
sg_set_error(SG_ERROR_DEVSTAT_SELECTDEVS, NULL);
return NULL;
}
#endif
for(counter=0;counter<stats.dinfo->numdevs;counter++){
dev_ptr=&stats.dinfo->devices[dev_sel[counter].position];
/* Throw away devices that have done nothing, ever.. Eg "odd"
* devices.. like mem, proc.. and also doesn't report floppy
* drives etc unless they are doing stuff :)
*/
#ifdef FREEBSD5
if((dev_ptr->bytes[DEVSTAT_READ]==0) && (dev_ptr->bytes[DEVSTAT_WRITE]==0)) continue;
#else
if((dev_ptr->bytes_read==0) && (dev_ptr->bytes_written==0)) continue;
#endif
if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
return NULL;
}
diskio_stats_ptr=diskio_stats+num_diskio;
#ifdef FREEBSD5
diskio_stats_ptr->read_bytes=dev_ptr->bytes[DEVSTAT_READ];
diskio_stats_ptr->write_bytes=dev_ptr->bytes[DEVSTAT_WRITE];
#else
diskio_stats_ptr->read_bytes=dev_ptr->bytes_read;
diskio_stats_ptr->write_bytes=dev_ptr->bytes_written;
#endif
if(diskio_stats_ptr->disk_name!=NULL) free(diskio_stats_ptr->disk_name);
if (asprintf((&diskio_stats_ptr->disk_name), "%s%d", dev_ptr->device_name, dev_ptr->unit_number) == -1) {
sg_set_error_with_errno(SG_ERROR_ASPRINTF, NULL);
return NULL;
}
diskio_stats_ptr->systime=time(NULL);
num_diskio++;
}
free(dev_sel);
#endif
#ifdef SOLARIS
if ((kc = kstat_open()) == NULL) {
sg_set_error(SG_ERROR_KSTAT_OPEN, NULL);
return NULL;
}
for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
if (!strcmp(ksp->ks_class, "disk")) {
if(ksp->ks_type != KSTAT_TYPE_IO) continue;
/* We dont want metadevices appearins as num_diskio */
if(strcmp(ksp->ks_module, "md")==0) continue;
if((kstat_read(kc, ksp, &kios))==-1){
}
if (VECTOR_RESIZE(diskio_stats, num_diskio + 1) < 0) {
kstat_close(kc);
return NULL;
}
diskio_stats_ptr=diskio_stats+num_diskio;
diskio_stats_ptr->read_bytes=kios.nread;
diskio_stats_ptr->write_bytes=kios.nwritten;
if (sg_update_string(&diskio_stats_ptr->disk_name,
sg_get_svr_from_bsd(ksp->ks_name)) < 0) {
kstat_close(kc);
return NULL;
}
diskio_stats_ptr->systime=time(NULL);
num_diskio++;
}
}
kstat_close(kc);
#endif
#ifdef LINUX
num_diskio = 0;
n = 0;
/* Read /proc/partitions to find what devices exist. Recent 2.4 kernels
have statistics in here too, so we can use those directly.
2.6 kernels have /proc/diskstats instead with almost (but not quite)
the same format. */
f = fopen("/proc/diskstats", "r");
format = " %d %d %99s %*d %*d %lld %*d %*d %*d %lld";
if (f == NULL) {
f = fopen("/proc/partitions", "r");
format = " %d %d %*d %99s %*d %*d %lld %*d %*d %*d %lld";
}
if (f == NULL) goto out;
now = time(NULL);
if (!re_compiled) {
if (regcomp(&part_re, "^(.*/)?[^/]*[0-9]$", REG_EXTENDED | REG_NOSUB) != 0) {
sg_set_error(SG_ERROR_PARSE, NULL);
goto out;
}
if (regcomp(¬_part_re, "^(.*/)?[^/0-9]+[0-9]+d[0-9]+$", REG_EXTENDED | REG_NOSUB) != 0) {
sg_set_error(SG_ERROR_PARSE, NULL);
goto out;
}
re_compiled = 1;
}
while ((line_ptr = sg_f_read_line(f, "")) != NULL) {
char name[100];
long long rsect, wsect;
int nr = sscanf(line_ptr, format,
&major, &minor, name, &rsect, &wsect);
if (nr < 3) continue;
/* Skip device names ending in numbers, since they're
partitions, unless they match the c0d0 pattern that some
RAID devices use. */
/* FIXME: For 2.6+, we should probably be using sysfs to detect
this... */
if ((regexec(&part_re, name, 0, NULL, 0) == 0)
&& (regexec(¬_part_re, name, 0, NULL, 0) != 0)) {
continue;
}
if (nr < 5) {
has_pp_stats = 0;
rsect = 0;
wsect = 0;
}
if (VECTOR_RESIZE(diskio_stats, n + 1) < 0) {
goto out;
}
if (VECTOR_RESIZE(parts, n + 1) < 0) {
goto out;
}
if (sg_update_string(&diskio_stats[n].disk_name, name) < 0) {
goto out;
}
diskio_stats[n].read_bytes = rsect * 512;
diskio_stats[n].write_bytes = wsect * 512;
diskio_stats[n].systime = now;
parts[n].major = major;
parts[n].minor = minor;
n++;
}
fclose(f);
f = NULL;
if (!has_pp_stats) {
/* This is an older kernel where /proc/partitions doesn't
contain stats. Read what we can from /proc/stat instead, and
fill in the appropriate bits of the list allocated above. */
f = fopen("/proc/stat", "r");
if (f == NULL) goto out;
now = time(NULL);
line_ptr = sg_f_read_line(f, "disk_io:");
if (line_ptr == NULL) goto out;
while((line_ptr=strchr(line_ptr, ' '))!=NULL){
long long rsect, wsect;
if (*++line_ptr == '\0') break;
if((sscanf(line_ptr,
"(%d,%d):(%*d, %*d, %lld, %*d, %lld)",
&major, &minor, &rsect, &wsect)) != 4) {
continue;
}
/* Find the corresponding device from earlier.
Just to add to the fun, "minor" is actually the disk
number, not the device minor, so we need to figure
out the real minor number based on the major!
This list is not exhaustive; if you're running
an older kernel you probably don't have fancy
I2O hardware anyway... */
switch (major) {
case 3:
case 21:
case 22:
case 33:
case 34:
case 36:
case 56:
case 57:
case 88:
case 89:
case 90:
case 91:
minor *= 64;
break;
case 9:
case 43:
break;
default:
minor *= 16;
break;
}
for (i = 0; i < n; i++) {
if (major == parts[i].major
&& minor == parts[i].minor)
break;
}
if (i == n) continue;
/* We read the number of blocks. Blocks are stored in
512 bytes */
diskio_stats[i].read_bytes = rsect * 512;
diskio_stats[i].write_bytes = wsect * 512;
diskio_stats[i].systime = now;
}
}
num_diskio = n;
out:
if (f != NULL) fclose(f);
#endif
#ifdef CYGWIN
sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
return NULL;
#endif
#ifdef WIN32
sg_set_error(SG_ERROR_NONE, NULL);
while((name = get_diskio(num_diskio, &rbytes, &wbytes)) != NULL) {
if (VECTOR_RESIZE(diskio_stats, num_diskio+1)) {
return NULL;
}
diskio_stats_ptr = diskio_stats + num_diskio;
if (sg_update_string(&diskio_stats_ptr->disk_name, name) < 0) {
return NULL;
}
sg_update_string(&name, NULL);
diskio_stats_ptr->read_bytes = rbytes;
diskio_stats_ptr->write_bytes = wbytes;
diskio_stats_ptr->systime = 0;
num_diskio++;
}
#endif
*entries=num_diskio;
return diskio_stats;
}
sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries){
#ifndef WIN32
VECTOR_DECLARE_STATIC(diff, sg_disk_io_stats, 1,
diskio_stat_init, diskio_stat_destroy);
sg_disk_io_stats *src = NULL, *dest;
int i, j, diff_count, new_count;
if (diskio_stats == NULL) {
/* No previous stats, so we can't calculate a difference. */
return sg_get_disk_io_stats(entries);
}
/* Resize the results array to match the previous stats. */
diff_count = VECTOR_SIZE(diskio_stats);
if (VECTOR_RESIZE(diff, diff_count) < 0) {
return NULL;
}
/* Copy the previous stats into the result. */
for (i = 0; i < diff_count; i++) {
src = &diskio_stats[i];
dest = &diff[i];
if (sg_update_string(&dest->disk_name, src->disk_name) < 0) {
return NULL;
}
dest->read_bytes = src->read_bytes;
dest->write_bytes = src->write_bytes;
dest->systime = src->systime;
}
/* Get a new set of stats. */
if (sg_get_disk_io_stats(&new_count) == NULL) {
return NULL;
}
/* For each previous stat... */
for (i = 0; i < diff_count; i++) {
dest = &diff[i];
/* ... find the corresponding new stat ... */
for (j = 0; j < new_count; j++) {
/* Try the new stat in the same position first,
since that's most likely to be it. */
src = &diskio_stats[(i + j) % new_count];
if (strcmp(src->disk_name, dest->disk_name) == 0) {
break;
}
}
if (j == new_count) {
/* No match found. */
continue;
}
/* ... and subtract the previous stat from it to get the
difference. */
dest->read_bytes = src->read_bytes - dest->read_bytes;
dest->write_bytes = src->write_bytes - dest->write_bytes;
dest->systime = src->systime - dest->systime;
}
*entries = diff_count;
return diff;
#else /* WIN32 */
return sg_get_disk_io_stats(entries);
#endif
}
int sg_disk_io_compare_name(const void *va, const void *vb) {
const sg_disk_io_stats *a = (const sg_disk_io_stats *)va;
const sg_disk_io_stats *b = (const sg_disk_io_stats *)vb;
return strcmp(a->disk_name, b->disk_name);
}
HRESULT CALLBACK DrivesContextMenuCallback(IShellFolder *psf,
HWND hwnd,
IDataObject *pdtobj,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
if (uMsg != DFM_MERGECONTEXTMENU && uMsg != DFM_INVOKECOMMAND)
return S_OK;
PIDLIST_ABSOLUTE pidlFolder;
PUITEMID_CHILD *apidl;
UINT cidl;
HRESULT hr = SH_GetApidlFromDataObject(pdtobj, &pidlFolder, &apidl, &cidl);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
char szDrive[8] = {0};
if (!_ILGetDrive(apidl[0], szDrive, sizeof(szDrive)))
{
ERR("pidl is not a drive\n");
SHFree(pidlFolder);
_ILFreeaPidl(apidl, cidl);
return E_FAIL;
}
if (uMsg == DFM_MERGECONTEXTMENU)
{
QCMINFO *pqcminfo = (QCMINFO *)lParam;
DWORD dwFlags;
if (GetVolumeInformationA(szDrive, NULL, 0, NULL, NULL, &dwFlags, NULL, 0))
{
/* Disable format if read only */
if (!(dwFlags & FILE_READ_ONLY_VOLUME) && GetDriveTypeA(szDrive) != DRIVE_REMOTE)
{
_InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0, MFT_SEPARATOR, NULL, 0);
_InsertMenuItemW(pqcminfo->hmenu, pqcminfo->indexMenu++, TRUE, 0x7ABC, MFT_STRING, MAKEINTRESOURCEW(IDS_FORMATDRIVE), MFS_ENABLED);
}
}
}
else if (uMsg == DFM_INVOKECOMMAND)
{
if(wParam == 0x7ABC)
{
SHFormatDrive(hwnd, szDrive[0] - 'A', SHFMT_ID_DEFAULT, 0);
}
else if (wParam == DFM_CMD_PROPERTIES)
{
WCHAR wszBuf[4];
wcscpy(wszBuf, L"A:\\");
wszBuf[0] = (WCHAR)szDrive[0];
if (!SH_ShowDriveProperties(wszBuf, pidlFolder, apidl))
hr = E_FAIL;
}
}
SHFree(pidlFolder);
_ILFreeaPidl(apidl, cidl);
return hr;
}
BOOL My_GetVolumeInformationA()
{
LPCSTR lpRootPathName=NULL;
LPSTR lpVolumeNameBuffer=NULL;
DWORD nVolumeNameSize=NULL;
LPDWORD lpVolumeSerialNumber=NULL;
LPDWORD lpMaximumComponentLength=NULL;
LPDWORD lpFileSystemFlags=NULL;
LPSTR lpFileSystemNameBuffer=NULL;
DWORD nFileSystemNameSize=NULL;
BOOL returnVal_Real = NULL;
BOOL returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
__try{
disableInterception();
returnVal_Real = GetVolumeInformationA (lpRootPathName,lpVolumeNameBuffer,nVolumeNameSize,lpVolumeSerialNumber,lpMaximumComponentLength,lpFileSystemFlags,lpFileSystemNameBuffer,nFileSystemNameSize);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = GetVolumeInformationA (lpRootPathName,lpVolumeNameBuffer,nVolumeNameSize,lpVolumeSerialNumber,lpMaximumComponentLength,lpFileSystemFlags,lpFileSystemNameBuffer,nFileSystemNameSize);
error_Intercepted = GetLastError();
}__except(puts("in filter"), 1){puts("exception caught");}
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}