bool MyGetLogicalDriveStrings(UStringVector &driveStrings)
{
driveStrings.Clear();
if (g_IsNT)
{
UINT32 size = GetLogicalDriveStringsW(0, NULL);
if (size == 0)
return false;
UString buffer;
UINT32 newSize = GetLogicalDriveStringsW(size, buffer.GetBuffer(size));
if (newSize == 0)
return false;
if (newSize > size)
return false;
UString string;
for (UINT32 i = 0; i < newSize; i++)
{
WCHAR c = buffer[i];
if (c == L'\0')
{
driveStrings.Add(string);
string.Empty();
}
else
string += c;
}
return string.IsEmpty();
}
CSysStringVector driveStringsA;
bool res = MyGetLogicalDriveStrings(driveStringsA);
for (int i = 0; i < driveStringsA.Size(); i++)
driveStrings.Add(GetUnicodeString(driveStringsA[i]));
return res;
}
int ustring_GetLogicalDriveStrings(lua_State *L)
{
int i;
wchar_t* buf;
DWORD len = GetLogicalDriveStringsW(0, NULL);
if(len)
{
buf = (wchar_t*)lua_newuserdata(L, (len+1)*sizeof(wchar_t));
if(GetLogicalDriveStringsW(len, buf))
{
lua_newtable(L);
for(i=1; TRUE; i++)
{
if(*buf == 0) break;
PutWStrToArray(L, i, buf, -1);
buf += wcslen(buf) + 1;
}
return 1;
}
}
return SysErrorReturn(L);
}
static std::vector<std::wstring>
GetDosDeviceNames()
{
std::vector<std::wstring> v;
std::vector<wchar_t> buf;
buf.resize(1024);
DWORD rv = GetLogicalDriveStringsW(buf.size(), buf.data());
if (rv == 0 || rv > buf.size()) {
return v;
}
// buf will be a list of null terminated strings, with the last string
// being 0 length.
const wchar_t* p = buf.data();
const wchar_t* end = &buf.back();
size_t l;
while (p < end && (l = wcsnlen_s(p, end - p)) > 0) {
// The string is of the form "C:\". We need to strip off the trailing
// backslash.
std::wstring drive = std::wstring(p, p + l);
if (drive.back() == '\\') {
drive.erase(drive.end() - 1);
}
v.push_back(move(drive));
p += l + 1;
}
return v;
}
void VDGetRootPaths(vdvector<VDStringW>& paths) {
union {
WCHAR w[512];
CHAR a[1024];
} buf;
if (VDIsWindowsNT()) {
vdfastvector<WCHAR> heapbufw;
WCHAR *pw = buf.w;
DWORD wlen = vdcountof(buf.w);
for(;;) {
*pw = 0;
DWORD r = GetLogicalDriveStringsW(wlen, pw);
if (!r)
return;
if (r <= wlen)
break;
heapbufw.resize(r);
wlen = r;
pw = heapbufw.data();
}
while(*pw) {
paths.push_back() = pw;
pw += wcslen(pw) + 1;
}
} else {
vdfastvector<CHAR> heapbufa;
CHAR *pa = buf.a;
DWORD alen = vdcountof(buf.a);
for(;;) {
*pa = 0;
DWORD r = GetLogicalDriveStringsA(alen, pa);
if (!r)
return;
if (r <= alen)
break;
heapbufa.resize(r);
alen = r;
pa = heapbufa.data();
}
while(*pa) {
paths.push_back() = VDTextAToW(pa);
pa += strlen(pa) + 1;
}
}
}
bool next( ) {
if ( ptr == nullptr ) {
unsigned buf_size = MAX_PATH;
drives.reset( new wchar_t[ buf_size ] );
DWORD len = GetLogicalDriveStringsW( buf_size, drives.get( ) );
if ( len > buf_size ) {
buf_size = len;
drives.reset( new wchar_t[ buf_size ] );
len = GetLogicalDriveStringsW( buf_size, drives.get( ) );
}
CHECK_SYS( len );
ptr = drives.get( );
}
else {
ptr = ptr + wcslen( ptr ) + 1;
}
return *ptr != 0;
}
static void
InitComboxList(HWND hDlg)
{
HWND hwndGroupsBox = GetDlgItem(hDlg, IDC_COMBOX_DISK);
wchar_t drives[SEAF_PATH_MAX];
wchar_t *p;
ULARGE_INTEGER free_space;
ULARGE_INTEGER largest_free_space;
int i = 0;
int largest_disk_index = 0;
largest_free_space.QuadPart = 0;
SendMessage (hwndGroupsBox, CB_RESETCONTENT, 0, 0);
GetLogicalDriveStringsW (sizeof(drives), drives);
for (p = drives; *p != L'\0'; p += wcslen(p) + 1) {
/* Skip floppy disk, network drive, etc */
if (GetDriveTypeW(p) != DRIVE_FIXED)
continue;
if (GetDiskFreeSpaceExW (p, &free_space, NULL, NULL)) {
if (free_space.QuadPart > largest_free_space.QuadPart) {
largest_free_space.QuadPart = free_space.QuadPart;
largest_disk_index = i;
}
} else {
free_space.QuadPart = 0;
applet_warning ("failed to GetDiskFreeSpaceEx(), GLE=%lu\n",
GetLastError());
}
wchar_t wbuf[128];
wchar_t *trans;
if (free_space.QuadPart) {
double space = ((double)(free_space.QuadPart)) / (1024 * 1024 * 1024);
trans = wchar_from_utf8 (_("free"));
_snwprintf (wbuf, sizeof(wbuf) / sizeof(wchar_t),
L"%s\t (%.1f GB %s)",
p, space, trans);
} else {
trans = wchar_from_utf8 (_("free space unknown"));
_snwprintf (wbuf, sizeof(wbuf), L"%s\t (%s)", p, trans);
}
g_free (trans);
i++;
SendMessageW (hwndGroupsBox, CB_ADDSTRING, 0, (LPARAM) wbuf);
}
SendDlgItemMessage (hDlg, IDC_COMBOX_DISK, CB_SETCURSEL, largest_disk_index, 0);
}
void PathImpl::listRootsImpl(std::vector<std::string>& roots)
{
roots.clear();
wchar_t buffer[128];
DWORD n = GetLogicalDriveStringsW(sizeof(buffer)/sizeof(wchar_t) - 1, buffer);
wchar_t* it = buffer;
wchar_t* end = buffer + (n > sizeof(buffer) ? sizeof(buffer) : n);
while (it < end)
{
std::wstring udev;
while (it < end && *it) udev += *it++;
std::string dev;
UnicodeConverter::toUTF8(udev, dev);
roots.push_back(dev);
++it;
}
}
/***********************************************************************
* SetupCreateDiskSpaceListW (SETUPAPI.@)
*/
HDSKSPC WINAPI SetupCreateDiskSpaceListW(PVOID Reserved1, DWORD Reserved2, UINT Flags)
{
WCHAR drives[255];
DWORD rc;
WCHAR *ptr;
LPDISKSPACELIST list=NULL;
TRACE("(%p, %u, 0x%08x)\n", Reserved1, Reserved2, Flags);
if (Reserved1 || Reserved2 || Flags & ~SPDSL_IGNORE_DISK)
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
rc = GetLogicalDriveStringsW(255,drives);
if (rc == 0)
return NULL;
list = HeapAlloc(GetProcessHeap(),0,sizeof(DISKSPACELIST));
list->dwDriveCount = 0;
ptr = drives;
while (*ptr)
{
DWORD type = GetDriveTypeW(ptr);
if (type == DRIVE_FIXED)
{
DWORD clusters;
DWORD sectors;
DWORD bytes;
DWORD total;
lstrcpyW(list->Drives[list->dwDriveCount].lpzName,ptr);
GetDiskFreeSpaceW(ptr,§ors,&bytes,&clusters,&total);
list->Drives[list->dwDriveCount].dwFreeSpace = clusters * sectors *
bytes;
list->Drives[list->dwDriveCount].dwWantedSpace = 0;
list->dwDriveCount++;
}
ptr += lstrlenW(ptr) + 1;
}
return list;
}
static gboolean
get_process_filename (HANDLE process, WCHAR * name, DWORD name_capacity)
{
gsize name_length;
WCHAR drive_strings[DRIVE_STRINGS_MAX_LENGTH];
WCHAR *drive;
if (GetProcessImageFileName (process, name, name_capacity) == 0)
return FALSE;
name_length = wcslen (name);
drive_strings[0] = L'\0';
drive_strings[DRIVE_STRINGS_MAX_LENGTH - 1] = L'\0';
GetLogicalDriveStringsW (DRIVE_STRINGS_MAX_LENGTH - 1, drive_strings);
for (drive = drive_strings; *drive != '\0'; drive += wcslen (drive) + 1)
{
WCHAR device_name[3];
WCHAR mapping_strings[MAX_PATH];
WCHAR *mapping;
gsize mapping_length;
wcsncpy_s (device_name, 3, drive, 2);
mapping_strings[0] = '\0';
mapping_strings[MAX_PATH - 1] = '\0';
QueryDosDevice (device_name, mapping_strings, MAX_PATH - 1);
for (mapping = mapping_strings; *mapping != '\0'; mapping += mapping_length + 1)
{
mapping_length = wcslen (mapping);
if (mapping_length > name_length)
continue;
if (wcsncmp (name, mapping, mapping_length) == 0)
{
wcscpy_s (name, 3, device_name);
memmove (name + 2, name + mapping_length, (name_length - mapping_length + 1) * sizeof (WCHAR));
return TRUE;
}
}
}
return FALSE;
}
void Path::ListRoots(std::vector<MistString>& arr) {
arr.clear();
#if defined(MIST_OS_WINDOWS)
wchar_t buffer[128];
DWORD n = GetLogicalDriveStringsW(sizeof(buffer)-1, buffer);
wchar_t* it = buffer;
wchar_t* end = buffer + (n > sizeof(buffer) ? sizeof(buffer): n);
while(it < end) {
std::wstring dev;
while(it < end && *it)
dev += *it++;
arr.push_back(dev);
++it;
}
#elif defined(MIST_OS_FAMILY_UNIX)
arr.push_back(L"/");
#endif
}
/***********************************************************************
* SetupCreateDiskSpaceListW (SETUPAPI.@)
*/
HDSKSPC WINAPI SetupCreateDiskSpaceListW(PVOID Reserved1, DWORD Reserved2, UINT Flags)
{
WCHAR drives[255];
DWORD rc;
WCHAR *ptr;
LPDISKSPACELIST list=NULL;
rc = GetLogicalDriveStringsW(255,drives);
if (rc == 0)
return NULL;
list = HeapAlloc(GetProcessHeap(),0,sizeof(DISKSPACELIST));
list->dwDriveCount = 0;
ptr = drives;
while (*ptr)
{
DWORD type = GetDriveTypeW(ptr);
if (type == DRIVE_FIXED)
{
DWORD clusters;
DWORD sectors;
DWORD bytes;
DWORD total;
lstrcpyW(list->Drives[list->dwDriveCount].lpzName,ptr);
GetDiskFreeSpaceW(ptr,§ors,&bytes,&clusters,&total);
list->Drives[list->dwDriveCount].dwFreeSpace = clusters * sectors *
bytes;
list->Drives[list->dwDriveCount].dwWantedSpace = 0;
list->dwDriveCount++;
}
ptr += lstrlenW(ptr) + 1;
}
return list;
}
UINT WINAPI DiscoverRemoveableDrives(ULONGLONG limitSize)
{
UINT index = 0;
wchar_t buffer[2048] = { 0 };
wchar_t drivePath[8] = { 0 };
wchar_t driveLetter[4] = { 0 };
DWORD iSub = 0;
DWORD iLength= GetLogicalDriveStringsW(2048, buffer);
for (iSub = 0; iSub < iLength; iSub += 4)
{
wcscpy_s(drivePath, buffer+iSub);
if (GetDriveTypeW(drivePath) == DRIVE_REMOVABLE&&GetVolumeInformationW(drivePath, NULL, 0, NULL, NULL, NULL, NULL, 0) == TRUE)
{
wcscpy_s(driveLetter, drivePath);
(wcsrchr(driveLetter, _T(':')))[1] = 0;
ULARGE_INTEGER lpFreeToCaller;
ULARGE_INTEGER lpTotalSize;
ULARGE_INTEGER lpFreeSize;
if (GetDiskFreeSpaceExW(drivePath, &lpFreeToCaller, &lpTotalSize, &lpFreeSize) ==TRUE)
{
if (limitSize>0){
if (lpTotalSize.QuadPart < limitSize)
continue;
}
swprintf_s(g_DriveList[index].sizeInfo, L"%s The total size of USB device: %4.1f GB |Free Space: %4.1f GB",
drivePath,
(float)(lpTotalSize.QuadPart) / (1024 * 1024 * 1024),
(float)(lpFreeSize.QuadPart) / (1024 * 1024 * 1024));
wcscpy_s(g_DriveList[index].driveLetter, driveLetter);
wcscpy_s(g_DriveList[index].drivePath, drivePath);
index++;
}
}
}
return index;
}
BOOL GetIMAPIBurningDevices(CArray<LPWSTR>& aDevicePaths)
{
CRegKey RegKey;
if (RegKey.OpenKey(HKCR,"IMAPI.MSDiscMasterObj\\CLSID",CRegKey::defRead)!=ERROR_SUCCESS)
return FALSE;
WCHAR szCLSID[50];
if (RegKey.QueryValue(L"",szCLSID,50)==0)
return FALSE;
CLSID clsid;
if (CLSIDFromString(szCLSID,&clsid)!=NO_ERROR)
return FALSE;
HRESULT hRes;
IDiscMaster* pdm;
hRes=CoCreateInstance(clsid,NULL,CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER,IID_IDiscMaster,(void**)&pdm);
if (FAILED(hRes))
return FALSE;
hRes=pdm->Open();
if (FAILED(hRes))
{
pdm->Release();
return FALSE;
}
IEnumDiscRecorders* pedr;
hRes=pdm->EnumDiscRecorders(&pedr);
if (SUCCEEDED(hRes))
{
IDiscRecorder* pdr;
DWORD dwReturned;
while ((hRes=pedr->Next(1,&pdr,&dwReturned))==S_OK)
{
BSTR bPath;
hRes=pdr->GetPath(&bPath);
if (SUCCEEDED(bPath))
{
if (bPath[0]=='\\')
{
WCHAR szName[MAX_PATH];
WCHAR szTemp[MAX_PATH]=L"";
WCHAR drive[]=L" :";
GetLogicalDriveStringsW(MAX_PATH,szTemp);
LPWSTR pPtr=szTemp;
while (*pPtr!='\0')
{
*drive=*pPtr;
if (QueryDosDeviceW(drive, szName,MAX_PATH))
{
if (wcscmp(szName,bPath)==0)
aDevicePaths.Add(alloccopy(pPtr));
}
pPtr+=istrlenw(pPtr)+1;
}
}
else
aDevicePaths.Add(alloccopy(bPath));
}
pdr->Release();
}
pedr->Release();
}
pdm->Close();
pdm->Release();
return TRUE;
}
JNIEXPORT void JNICALL
Java_net_rubygrapefruit_platform_internal_jni_PosixFileSystemFunctions_listFileSystems(JNIEnv *env, jclass target, jobject info, jobject result) {
jclass info_class = env->GetObjectClass(info);
jmethodID method = env->GetMethodID(info_class, "add", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZZ)V");
DWORD required = GetLogicalDriveStringsW(0, NULL);
if (required == 0) {
mark_failed_with_errno(env, "could not determine logical drive buffer size", result);
return;
}
wchar_t* buffer = (wchar_t*)malloc(sizeof(wchar_t) * (required + 1));
wchar_t* deviceName = (wchar_t*)malloc(sizeof(wchar_t) * (MAX_PATH + 1));
wchar_t* fileSystemName = (wchar_t*)malloc(sizeof(wchar_t) * (MAX_PATH + 1));
if (GetLogicalDriveStringsW(required, buffer) == 0) {
mark_failed_with_errno(env, "could not determine logical drives", result);
} else {
wchar_t* cur = buffer;
for (;cur[0] != L'\0'; cur += wcslen(cur) + 1) {
DWORD type = GetDriveTypeW(cur);
jboolean remote = type == DRIVE_REMOTE;
// chop off trailing '\'
size_t len = wcslen(cur);
cur[len-1] = L'\0';
// create device name \\.\C:
wchar_t devPath[7];
swprintf(devPath, 7, L"\\\\.\\%s", cur);
if (QueryDosDeviceW(cur, deviceName, MAX_PATH+1) == 0) {
mark_failed_with_errno(env, "could not map device for logical drive", result);
break;
}
cur[len-1] = L'\\';
DWORD available = 1;
if (!remote) {
HANDLE hDevice = CreateFileW(devPath, // like "\\.\E:"
FILE_READ_ATTRIBUTES, // read access to the attributes
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, // share mode
NULL, OPEN_EXISTING, 0, NULL);
if (hDevice != INVALID_HANDLE_VALUE) {
DWORD cbBytesReturned;
DWORD bSuccess = DeviceIoControl (hDevice, // device to be queried
IOCTL_STORAGE_CHECK_VERIFY2,
NULL, 0, // no input buffer
NULL, 0, // no output buffer
&cbBytesReturned, // # bytes returned
(LPOVERLAPPED) NULL); // synchronous I/O
if (!bSuccess) {
available = 0;
}
CloseHandle(hDevice);
}
}
jboolean casePreserving = JNI_TRUE;
if (available) {
DWORD flags;
if (GetVolumeInformationW(cur, NULL, 0, NULL, NULL, &flags, fileSystemName, MAX_PATH+1) == 0) {
mark_failed_with_errno(env, "could not get volume information", result);
break;
}
casePreserving = (flags & FILE_CASE_PRESERVED_NAMES) != 0;
} else {
if (type == DRIVE_CDROM) {
swprintf(fileSystemName, MAX_PATH+1, L"cdrom");
} else {
swprintf(fileSystemName, MAX_PATH+1, L"unknown");
}
}
env->CallVoidMethod(info, method,
wchar_to_java(env, cur, wcslen(cur), result),
wchar_to_java(env, fileSystemName, wcslen(fileSystemName), result),
wchar_to_java(env, deviceName, wcslen(deviceName), result),
remote, JNI_FALSE, casePreserving);
}
}
free(buffer);
free(deviceName);
free(fileSystemName);
}
