/**********************************************************************
* DOSVM_Int25Handler
*
* Handler for int 25h (absolute disk read).
*/
void WINAPI DOSVM_Int25Handler( CONTEXT *context )
{
WCHAR drivespec[4] = {'A', ':', '\\', 0};
BYTE *dataptr = CTX_SEG_OFF_TO_LIN( context, context->SegDs, context->Ebx );
DWORD begin;
DWORD length;
drivespec[0] += AL_reg( context );
if (GetDriveTypeW( drivespec ) == DRIVE_NO_ROOT_DIR ||
GetDriveTypeW( drivespec ) == DRIVE_UNKNOWN)
{
SET_CFLAG( context );
SET_AX( context, 0x0201 ); /* unknown unit */
return;
}
if (CX_reg( context ) == 0xffff)
{
begin = *(DWORD *)dataptr;
length = *(WORD *)(dataptr + 4);
dataptr = (BYTE *)CTX_SEG_OFF_TO_LIN( context,
*(WORD *)(dataptr + 8),
*(DWORD *)(dataptr + 6) );
}
else
{
begin = DX_reg( context );
length = CX_reg( context );
}
DOSVM_RawRead( AL_reg( context ), begin, length, dataptr, TRUE );
RESET_CFLAG( context );
}
HRESULT WINAPI
CDrvDefExt::AddPages(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
{
HPROPSHEETPAGE hPage;
hPage = SH_CreatePropertySheetPage(IDD_DRIVE_PROPERTIES,
GeneralPageProc,
(LPARAM)this,
NULL);
if (hPage)
pfnAddPage(hPage, lParam);
if (GetDriveTypeW(m_wszDrive) == DRIVE_FIXED)
{
hPage = SH_CreatePropertySheetPage(IDD_DRIVE_TOOLS,
ExtraPageProc,
(LPARAM)this,
NULL);
if (hPage)
pfnAddPage(hPage, lParam);
}
hPage = SH_CreatePropertySheetPage(IDD_DRIVE_HARDWARE,
HardwarePageProc,
(LPARAM)this,
NULL);
if (hPage)
pfnAddPage(hPage, lParam);
return S_OK;
}
BOOL My_GetDriveTypeW()
{
LPCWSTR lpRootPathName=NULL;
UINT returnVal_Real = NULL;
UINT returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = GetDriveTypeW (lpRootPathName);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = GetDriveTypeW (lpRootPathName);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
/*********************************************************************
* _wgetdcwd (MSVCRT.@)
*
* Unicode version of _wgetdcwd.
*/
MSVCRT_wchar_t* CDECL MSVCRT__wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
{
static MSVCRT_wchar_t* dummy;
TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
if (!drive || drive == MSVCRT__getdrive())
return MSVCRT__wgetcwd(buf,size); /* current */
else
{
MSVCRT_wchar_t dir[MAX_PATH];
MSVCRT_wchar_t drivespec[4] = {'A', ':', '\\', 0};
int dir_len;
drivespec[0] += drive - 1;
if (GetDriveTypeW(drivespec) < DRIVE_REMOVABLE)
{
*MSVCRT__errno() = MSVCRT_EACCES;
return NULL;
}
dir_len = GetFullPathNameW(drivespec,MAX_PATH,dir,&dummy);
if (dir_len >= size || dir_len < 1)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
return NULL; /* buf too small */
}
TRACE(":returning %s\n", debugstr_w(dir));
if (!buf)
return MSVCRT__wcsdup(dir); /* allocate */
strcpyW(buf,dir);
}
return buf;
}
static DWORD get_drive_type(WCHAR drive)
{
static const WCHAR rootW[] = {'a',':','\\',0};
WCHAR path[16];
memcpy( path, rootW, sizeof(rootW));
path[0] = drive;
return GetDriveTypeW(path);
}
static void test_GetDiskFreeSpaceW(void)
{
BOOL ret;
DWORD sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters;
WCHAR drive[] = {'?',':','\\',0};
DWORD logical_drives;
static const WCHAR empty_pathW[] = { 0 };
static const WCHAR root_pathW[] = { '\\', 0 };
static const WCHAR unix_style_root_pathW[] = { '/', 0 };
ret = GetDiskFreeSpaceW(NULL, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
win_skip("GetDiskFreeSpaceW is not available\n");
return;
}
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(empty_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(\"\"): ret=%d GetLastError=%d\n",
ret, GetLastError());
ret = GetDiskFreeSpaceW(root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW(\"\") error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(unix_style_root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
logical_drives = GetLogicalDrives();
ok(logical_drives != 0, "GetLogicalDrives error %d\n", GetLastError());
for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++)
{
UINT drivetype = GetDriveTypeW(drive);
/* Skip floppy drives because NT4 pops up a MessageBox if no floppy is present */
if (drivetype != DRIVE_REMOVABLE && drivetype != DRIVE_NO_ROOT_DIR)
{
ret = GetDiskFreeSpaceW(drive, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (!(logical_drives & 1))
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(%c): ret=%d GetLastError=%d\n",
drive[0], ret, GetLastError());
else
ok( ret ||
GetLastError() == ERROR_NOT_READY ||
GetLastError() == ERROR_INVALID_FUNCTION ||
GetLastError() == ERROR_PATH_NOT_FOUND ||
GetLastError() == ERROR_REQUEST_ABORTED ||
GetLastError() == ERROR_UNRECOGNIZED_VOLUME,
"GetDiskFreeSpaceW(%c): ret=%d GetLastError=%d\n",
drive[0], ret, GetLastError());
}
logical_drives >>= 1;
}
}
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);
}
L004010A0()
{
/* unknown */ void ebp;
(save)edi;
L00401518(edx, edx);
(restore)edi;
GetSystemDefaultLCID();
return(GetDriveTypeW(0));
}
L004012A4()
{
/* unknown */ void ebp;
(save)edi;
L004011E8(ebx, edx, ecx);
(restore)edi;
GetACP();
return(GetDriveTypeW(0));
}
/***********************************************************************
* GetDriveType (KERNEL.136)
* Get the type of a drive in Win16.
*
* RETURNS
* The type of the Drive. For a list see GetDriveTypeW from kernel32.
*
* NOTES
* Note that it returns DRIVE_REMOTE for CD-ROMs, since MSCDEX uses the
* remote drive API. The return value DRIVE_REMOTE for CD-ROMs has been
* verified on Win 3.11 and Windows 95. Some programs rely on it, so don't
* do any pseudo-clever changes.
*/
UINT16 WINAPI GetDriveType16( UINT16 drive ) /* [in] number (NOT letter) of drive */
{
UINT type;
WCHAR root[3];
root[0] = 'A' + drive;
root[1] = ':';
root[2] = 0;
type = GetDriveTypeW( root );
if (type == DRIVE_CDROM) type = DRIVE_REMOTE;
else if (type == DRIVE_NO_ROOT_DIR) type = DRIVE_UNKNOWN;
return type;
}
/**
* Determines if the file system for the specified file handle is local
* @param file path to check the filesystem type for, must be at most MAX_PATH
* @param isLocal out parameter which will hold TRUE if the drive is local
* @return TRUE if the call succeeded
*/
BOOL
IsLocalFile(LPCWSTR file, BOOL &isLocal)
{
WCHAR rootPath[MAX_PATH + 1] = { L'\0' };
if (wcslen(file) > MAX_PATH) {
return FALSE;
}
wcsncpy(rootPath, file, MAX_PATH);
PathStripToRootW(rootPath);
isLocal = GetDriveTypeW(rootPath) == DRIVE_FIXED;
return TRUE;
}
UINT MyGetDriveType(CFSTR pathName)
{
#ifndef _UNICODE
if (!g_IsNT)
{
return GetDriveType(fs2fas(pathName));
}
else
#endif
{
return GetDriveTypeW(fs2us(pathName));
}
}
static void test_GetDiskFreeSpaceW(void)
{
BOOL ret;
DWORD sectors_per_cluster, bytes_per_sector, free_clusters, total_clusters;
WCHAR drive[] = {'?',':','\\',0};
DWORD logical_drives;
static const WCHAR empty_pathW[] = { 0 };
static const WCHAR root_pathW[] = { '\\', 0 };
static const WCHAR unix_style_root_pathW[] = { '/', 0 };
ret = GetDiskFreeSpaceW(NULL, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (ret == 0 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
win_skip("GetDiskFreeSpaceW is not available\n");
return;
}
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(empty_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(\"\"): ret=%d GetLastError=%d\n",
ret, GetLastError());
ret = GetDiskFreeSpaceW(root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW(\"\") error %d\n", GetLastError());
ret = GetDiskFreeSpaceW(unix_style_root_pathW, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
ok(ret, "GetDiskFreeSpaceW error %d\n", GetLastError());
logical_drives = GetLogicalDrives();
ok(logical_drives != 0, "GetLogicalDrives error %d\n", GetLastError());
for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++)
{
UINT drivetype = GetDriveTypeW(drive);
/* Skip floppy drives because NT4 pops up a MessageBox if no floppy is present */
if (drivetype != DRIVE_REMOVABLE && drivetype != DRIVE_NO_ROOT_DIR)
{
ret = GetDiskFreeSpaceW(drive, §ors_per_cluster, &bytes_per_sector, &free_clusters, &total_clusters);
if (!(logical_drives & 1))
ok(!ret && GetLastError() == ERROR_PATH_NOT_FOUND,
"GetDiskFreeSpaceW(%c): ret=%d GetLastError=%d\n",
drive[0], ret, GetLastError());
else if (!ret)
/* GetDiskFreeSpaceW() should succeed, but it can fail with too many
different GetLastError() results to be usable for an ok() */
trace("GetDiskFreeSpaceW(%c) failed with %d\n", drive[0], GetLastError());
}
logical_drives >>= 1;
}
}
static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
LPCWSTR path, int depth, LPWSTR *appValue)
{
UINT rc;
TRACE("%p, %p, %s, %d, %p\n", package, sig, debugstr_w(path), depth,
appValue);
if (ACTION_IsFullPath(path))
{
if (sig->File)
rc = ACTION_RecurseSearchDirectory(package, appValue, sig,
path, depth);
else
{
/* Recursively searching a directory makes no sense when the
* directory to search is the thing you're trying to find.
*/
rc = ACTION_CheckDirectory(package, path, appValue);
}
}
else
{
WCHAR pathWithDrive[MAX_PATH] = { 'C',':','\\',0 };
DWORD drives = GetLogicalDrives();
int i;
rc = ERROR_SUCCESS;
*appValue = NULL;
for (i = 0; rc == ERROR_SUCCESS && !*appValue && i < 26; i++)
if (drives & (1 << i))
{
pathWithDrive[0] = 'A' + i;
if (GetDriveTypeW(pathWithDrive) == DRIVE_FIXED)
{
lstrcpynW(pathWithDrive + 3, path,
sizeof(pathWithDrive) / sizeof(pathWithDrive[0]) - 3);
if (sig->File)
rc = ACTION_RecurseSearchDirectory(package, appValue,
sig, pathWithDrive, depth);
else
rc = ACTION_CheckDirectory(package, pathWithDrive,
appValue);
}
}
}
TRACE("returning %d\n", rc);
return rc;
}
/***********************************************************************
* 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;
}
/* Returns the working directory for the given drive, or NULL */
WCHAR*
currentDir(int di) {
UINT dt;
WCHAR root[4];
// verify drive is valid as _wgetdcwd in the VC++ 2010 runtime
// library does not handle invalid drives.
root[0] = L'A' + (WCHAR)(di - 1);
root[1] = L':';
root[2] = L'\\';
root[3] = L'\0';
dt = GetDriveTypeW(root);
if (dt == DRIVE_UNKNOWN || dt == DRIVE_NO_ROOT_DIR) {
return NULL;
} else {
return _wgetdcwd(di, NULL, MAX_PATH);
}
}
static int is_valid_drive(int device_index) {
WCHAR drive_path[4] = {L'?', L':', L'\\', L'\0'};
if(device_index == 0) {
/* Default drive; always valid. */
return 1;
} else if(device_index > (L'Z' - L'A' + 1)) {
return 0;
}
drive_path[0] = device_index + L'A' - 1;
switch(GetDriveTypeW(drive_path)) {
case DRIVE_NO_ROOT_DIR:
case DRIVE_UNKNOWN:
return 0;
}
return 1;
}
apr_status_t filepath_root_test(char *path, apr_pool_t *p)
{
apr_status_t rv;
#if APR_HAS_UNICODE_FS
if (apr_os_level >= APR_WIN_NT)
{
apr_wchar_t wpath[APR_PATH_MAX];
if (rv = utf8_to_unicode_path(wpath, sizeof(wpath)
/ sizeof(apr_wchar_t), path))
return rv;
rv = GetDriveTypeW(wpath);
}
else
#endif
rv = GetDriveType(path);
if (rv == DRIVE_UNKNOWN || rv == DRIVE_NO_ROOT_DIR)
return APR_EBADPATH;
return APR_SUCCESS;
}
KFilePlacesModel::KFilePlacesModel(QObject *parent)
: QAbstractItemModel(parent), d(new Private(this))
{
const QString file = KStandardDirs::locateLocal("data", "kfileplaces/bookmarks.xml");
d->bookmarkManager = KBookmarkManager::managerForFile(file, "kfilePlaces");
// Let's put some places in there if it's empty. We have a corner case here:
// Given you have bookmarked some folders (which have been saved on
// ~/.local/share/user-places.xbel (according to freedesktop bookmarks spec), and
// deleted the home directory ~/.kde, the call managerForFile() will return the
// bookmark manager for the fallback "kfilePlaces", making root.first().isNull() being
// false (you have your own items bookmarked), resulting on only being added your own
// bookmarks, and not the default ones too. So, we also check if kfileplaces/bookmarks.xml
// file exists, and if it doesn't, we also add the default places. (ereslibre)
KBookmarkGroup root = d->bookmarkManager->root();
if (root.first().isNull() || !QFile::exists(file)) {
// NOTE: The context for these I18N_NOOP2 calls has to be "KFile System Bookmarks".
// The real i18nc call is made later, with this context, so the two must match.
//
// createSystemBookmark actually does nothing with its third argument,
// but we have to give it something so the I18N_NOOP2 calls stay here for now.
//
// (coles, 13th May 2009)
KFilePlacesItem::createSystemBookmark(d->bookmarkManager,
"Home", I18N_NOOP2("KFile System Bookmarks", "Home"),
KUrl(KUser().homeDir()), "user-home");
KFilePlacesItem::createSystemBookmark(d->bookmarkManager,
"Network", I18N_NOOP2("KFile System Bookmarks", "Network"),
KUrl("remote:/"), "network-workgroup");
#ifdef Q_OS_WIN
// adding drives
foreach ( const QFileInfo& info, QDir::drives() ) {
#ifndef _WIN32_WCE
uint type = DRIVE_UNKNOWN;
#endif
QString driveIcon = "drive-harddisk";
#ifndef _WIN32_WCE
QT_WA({ type = GetDriveTypeW((wchar_t *)info.absoluteFilePath().utf16()); },
{ type = GetDriveTypeA(info.absoluteFilePath().toLocal8Bit()); });
int ustring_GetDriveType(lua_State *L)
{
const wchar_t *root = opt_utf8_string(L, 1, NULL);
const char* out;
UINT tp = GetDriveTypeW(root);
switch(tp)
{
default:
case 0: out = "unknown type"; break;
case 1: out = "no root directory"; break;
case DRIVE_REMOVABLE: out = "removable"; break;
case DRIVE_FIXED: out = "fixed"; break;
case DRIVE_REMOTE: out = "remote"; break;
case DRIVE_CDROM: out = "cdrom"; break;
case DRIVE_RAMDISK: out = "ramdisk"; break;
}
lua_pushstring(L, out);
return 1;
}
void KonqCopyToMainMenu::slotAboutToShow()
{
clear();
KonqCopyToDirectoryMenu* subMenu;
// Home Folder
subMenu = new KonqCopyToDirectoryMenu(this, this, QDir::homePath());
subMenu->setTitle(i18nc("@title:menu", "Home Folder"));
subMenu->setIcon(QIcon::fromTheme("go-home"));
addMenu(subMenu);
// Root Folder
#ifndef Q_OS_WIN
subMenu = new KonqCopyToDirectoryMenu(this, this, QDir::rootPath());
subMenu->setTitle(i18nc("@title:menu", "Root Folder"));
subMenu->setIcon(QIcon::fromTheme("folder-red"));
addMenu(subMenu);
#else
foreach ( const QFileInfo& info, QDir::drives() ) {
uint type = DRIVE_UNKNOWN;
QString driveIcon = "drive-harddisk";
QT_WA({ type = GetDriveTypeW((wchar_t *)info.absoluteFilePath().utf16()); },
{ type = GetDriveTypeA(info.absoluteFilePath().toLocal8Bit()); });
/***********************************************************************
* 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;
}
static void test_GetDriveTypeW(void)
{
WCHAR drive[] = {'?',':','\\',0};
DWORD logical_drives;
UINT type;
logical_drives = GetLogicalDrives();
ok(logical_drives != 0, "GetLogicalDrives error %d\n", GetLastError());
for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++)
{
type = GetDriveTypeW(drive);
ok(type > DRIVE_UNKNOWN && type <= DRIVE_RAMDISK,
"not a valid drive %c: type %u\n", drive[0], type);
if (!(logical_drives & 1))
ok(type == DRIVE_NO_ROOT_DIR,
"GetDriveTypeW should return DRIVE_NO_ROOT_DIR for inexistent drive %c: but not %u\n",
drive[0], type);
logical_drives >>= 1;
}
}
nsresult
FileSystemDataSource::GetVolumeList(nsISimpleEnumerator** aResult)
{
nsCOMArray<nsIRDFResource> volumes;
nsCOMPtr<nsIRDFResource> vol;
#ifdef XP_WIN
int32_t driveType;
wchar_t drive[32];
int32_t volNum;
for (volNum = 0; volNum < 26; volNum++)
{
swprintf( drive, L"%c:\\", volNum + (char16_t)'A');
driveType = GetDriveTypeW(drive);
if (driveType != DRIVE_UNKNOWN && driveType != DRIVE_NO_ROOT_DIR)
{
nsAutoCString url;
url.AppendPrintf("file:///%c|/", volNum + 'A');
nsresult rv = mRDFService->GetResource(url, getter_AddRefs(vol));
if (NS_FAILED(rv))
return rv;
volumes.AppendObject(vol);
}
}
#endif
#ifdef XP_UNIX
mRDFService->GetResource(NS_LITERAL_CSTRING("file:///"), getter_AddRefs(vol));
volumes.AppendObject(vol);
#endif
return NS_NewArrayEnumerator(aResult, volumes);
}
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;
}
static HRESULT map_url_to_zone(LPCWSTR url, DWORD *zone, LPWSTR *ret_url)
{
LPWSTR secur_url;
WCHAR schema[64];
DWORD size=0;
HRESULT hres;
*zone = URLZONE_INVALID;
hres = CoInternetGetSecurityUrl(url, &secur_url, PSU_SECURITY_URL_ONLY, 0);
if(hres != S_OK) {
size = strlenW(url)*sizeof(WCHAR);
secur_url = heap_alloc(size);
if(!secur_url)
return E_OUTOFMEMORY;
memcpy(secur_url, url, size);
}
hres = CoInternetParseUrl(secur_url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(WCHAR), &size, 0);
if(FAILED(hres) || !*schema) {
heap_free(secur_url);
return E_INVALIDARG;
}
/* file protocol is a special case */
if(!strcmpW(schema, fileW)) {
WCHAR path[MAX_PATH], root[20];
WCHAR *ptr;
hres = CoInternetParseUrl(secur_url, PARSE_PATH_FROM_URL, 0, path,
sizeof(path)/sizeof(WCHAR), &size, 0);
if(SUCCEEDED(hres) && (ptr = strchrW(path, '\\')) && ptr-path < sizeof(root)/sizeof(WCHAR)) {
UINT type;
memcpy(root, path, (ptr-path)*sizeof(WCHAR));
root[ptr-path] = 0;
type = GetDriveTypeW(root);
switch(type) {
case DRIVE_UNKNOWN:
case DRIVE_NO_ROOT_DIR:
break;
case DRIVE_REMOVABLE:
case DRIVE_FIXED:
case DRIVE_CDROM:
case DRIVE_RAMDISK:
*zone = URLZONE_LOCAL_MACHINE;
hres = S_OK;
break;
case DRIVE_REMOTE:
*zone = URLZONE_INTERNET;
hres = S_OK;
break;
default:
FIXME("unsupported drive type %d\n", type);
}
}
}
if(*zone == URLZONE_INVALID) {
WARN("domains are not yet implemented\n");
hres = get_zone_from_reg(schema, zone);
}
if(FAILED(hres) || !ret_url)
heap_free(secur_url);
else
*ret_url = secur_url;
return hres;
}
void requester_freeze(int *num_vols, void *mountpoints, ErrorSet *errset)
{
COMPointer<IVssAsync> pAsync;
HANDLE volume;
HRESULT hr;
LONG ctx;
GUID guidSnapshotSet = GUID_NULL;
SECURITY_DESCRIPTOR sd;
SECURITY_ATTRIBUTES sa;
WCHAR short_volume_name[64], *display_name = short_volume_name;
DWORD wait_status;
int num_fixed_drives = 0, i;
int num_mount_points = 0;
if (vss_ctx.pVssbc) { /* already frozen */
*num_vols = 0;
return;
}
CoInitialize(NULL);
/* Allow unrestricted access to events */
InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = &sd;
sa.bInheritHandle = FALSE;
vss_ctx.hEventFrozen = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_FROZEN);
if (!vss_ctx.hEventFrozen) {
err_set(errset, GetLastError(), "failed to create event %s",
EVENT_NAME_FROZEN);
goto out;
}
vss_ctx.hEventThaw = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_THAW);
if (!vss_ctx.hEventThaw) {
err_set(errset, GetLastError(), "failed to create event %s",
EVENT_NAME_THAW);
goto out;
}
vss_ctx.hEventTimeout = CreateEvent(&sa, TRUE, FALSE, EVENT_NAME_TIMEOUT);
if (!vss_ctx.hEventTimeout) {
err_set(errset, GetLastError(), "failed to create event %s",
EVENT_NAME_TIMEOUT);
goto out;
}
assert(pCreateVssBackupComponents != NULL);
hr = pCreateVssBackupComponents(&vss_ctx.pVssbc);
if (FAILED(hr)) {
err_set(errset, hr, "failed to create VSS backup components");
goto out;
}
hr = vss_ctx.pVssbc->InitializeForBackup();
if (FAILED(hr)) {
err_set(errset, hr, "failed to initialize for backup");
goto out;
}
hr = vss_ctx.pVssbc->SetBackupState(true, true, VSS_BT_FULL, false);
if (FAILED(hr)) {
err_set(errset, hr, "failed to set backup state");
goto out;
}
/*
* Currently writable snapshots are not supported.
* To prevent the final commit (which requires to write to snapshots),
* ATTR_NO_AUTORECOVERY and ATTR_TRANSPORTABLE are specified here.
*/
ctx = VSS_CTX_APP_ROLLBACK | VSS_VOLSNAP_ATTR_TRANSPORTABLE |
VSS_VOLSNAP_ATTR_NO_AUTORECOVERY | VSS_VOLSNAP_ATTR_TXF_RECOVERY;
hr = vss_ctx.pVssbc->SetContext(ctx);
if (hr == (HRESULT)VSS_E_UNSUPPORTED_CONTEXT) {
/* Non-server version of Windows doesn't support ATTR_TRANSPORTABLE */
ctx &= ~VSS_VOLSNAP_ATTR_TRANSPORTABLE;
hr = vss_ctx.pVssbc->SetContext(ctx);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to set backup context");
goto out;
}
hr = vss_ctx.pVssbc->GatherWriterMetadata(pAsync.replace());
if (SUCCEEDED(hr)) {
hr = WaitForAsync(pAsync);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to gather writer metadata");
goto out;
}
AddComponents(errset);
if (err_is_set(errset)) {
goto out;
}
hr = vss_ctx.pVssbc->StartSnapshotSet(&guidSnapshotSet);
if (FAILED(hr)) {
err_set(errset, hr, "failed to start snapshot set");
goto out;
}
if (mountpoints) {
PWCHAR volume_name_wchar;
for (volList *list = (volList *)mountpoints; list; list = list->next) {
size_t len = strlen(list->value) + 1;
size_t converted = 0;
VSS_ID pid;
volume_name_wchar = new wchar_t[len];
mbstowcs_s(&converted, volume_name_wchar, len,
list->value, _TRUNCATE);
hr = vss_ctx.pVssbc->AddToSnapshotSet(volume_name_wchar,
g_gProviderId, &pid);
if (FAILED(hr)) {
err_set(errset, hr, "failed to add %S to snapshot set",
volume_name_wchar);
delete volume_name_wchar;
goto out;
}
num_mount_points++;
delete volume_name_wchar;
}
if (num_mount_points == 0) {
/* If there is no valid mount points, just exit. */
goto out;
}
}
if (!mountpoints) {
volume = FindFirstVolumeW(short_volume_name, sizeof(short_volume_name));
if (volume == INVALID_HANDLE_VALUE) {
err_set(errset, hr, "failed to find first volume");
goto out;
}
for (;;) {
if (GetDriveTypeW(short_volume_name) == DRIVE_FIXED) {
VSS_ID pid;
hr = vss_ctx.pVssbc->AddToSnapshotSet(short_volume_name,
g_gProviderId, &pid);
if (FAILED(hr)) {
WCHAR volume_path_name[PATH_MAX];
if (GetVolumePathNamesForVolumeNameW(
short_volume_name, volume_path_name,
sizeof(volume_path_name), NULL) &&
*volume_path_name) {
display_name = volume_path_name;
}
err_set(errset, hr, "failed to add %S to snapshot set",
display_name);
FindVolumeClose(volume);
goto out;
}
num_fixed_drives++;
}
if (!FindNextVolumeW(volume, short_volume_name,
sizeof(short_volume_name))) {
FindVolumeClose(volume);
break;
}
}
if (num_fixed_drives == 0) {
goto out; /* If there is no fixed drive, just exit. */
}
}
hr = vss_ctx.pVssbc->PrepareForBackup(pAsync.replace());
if (SUCCEEDED(hr)) {
hr = WaitForAsync(pAsync);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to prepare for backup");
goto out;
}
hr = vss_ctx.pVssbc->GatherWriterStatus(pAsync.replace());
if (SUCCEEDED(hr)) {
hr = WaitForAsync(pAsync);
}
if (FAILED(hr)) {
err_set(errset, hr, "failed to gather writer status");
goto out;
}
/*
* Start VSS quiescing operations.
* CQGAVssProvider::CommitSnapshots will kick vss_ctx.hEventFrozen
* after the applications and filesystems are frozen.
*/
hr = vss_ctx.pVssbc->DoSnapshotSet(&vss_ctx.pAsyncSnapshot);
if (FAILED(hr)) {
err_set(errset, hr, "failed to do snapshot set");
goto out;
}
/* Need to call QueryStatus several times to make VSS provider progress */
for (i = 0; i < VSS_TIMEOUT_FREEZE_MSEC/VSS_TIMEOUT_EVENT_MSEC; i++) {
HRESULT hr2 = vss_ctx.pAsyncSnapshot->QueryStatus(&hr, NULL);
if (FAILED(hr2)) {
err_set(errset, hr, "failed to do snapshot set");
goto out;
}
if (hr != VSS_S_ASYNC_PENDING) {
err_set(errset, E_FAIL,
"DoSnapshotSet exited without Frozen event");
goto out;
}
wait_status = WaitForSingleObject(vss_ctx.hEventFrozen,
VSS_TIMEOUT_EVENT_MSEC);
if (wait_status != WAIT_TIMEOUT) {
break;
}
}
if (wait_status == WAIT_TIMEOUT) {
err_set(errset, E_FAIL,
"timeout when try to receive Frozen event from VSS provider");
/* If we are here, VSS had timeout.
* Don't call AbortBackup, just return directly.
*/
goto out1;
}
if (wait_status != WAIT_OBJECT_0) {
err_set(errset, E_FAIL,
"couldn't receive Frozen event from VSS provider");
goto out;
}
if (mountpoints) {
*num_vols = vss_ctx.cFrozenVols = num_mount_points;
} else {
*num_vols = vss_ctx.cFrozenVols = num_fixed_drives;
}
return;
out:
if (vss_ctx.pVssbc) {
vss_ctx.pVssbc->AbortBackup();
}
out1:
requester_cleanup();
CoUninitialize();
}
static void test_WNetGetRemoteName(void)
{
DWORD ret;
char buffer[1024];
DWORD drive_type, info_size, fail_size;
char driveA[] = "A:\\";
char driveandpathA[] = "A:\\file.txt";
WCHAR driveW[] = {'A',':','\\',0};
for(; *driveA <= 'Z'; ++*driveA, ++*driveandpathA, ++*driveW){
drive_type = GetDriveTypeW(driveW);
info_size = sizeof(buffer);
ret = WNetGetUniversalNameA(driveA, REMOTE_NAME_INFO_LEVEL,
buffer, &info_size);
if(drive_type == DRIVE_REMOTE)
todo_wine
ok(ret == WN_NO_ERROR, "WNetGetUniversalNameA failed: %08x\n", ret);
else
ok(ret == WN_NOT_CONNECTED || ret == WN_NO_NET_OR_BAD_PATH,
"(%s) WNetGetUniversalNameA gave wrong error: %u\n", driveA, ret);
ok(info_size == sizeof(buffer), "Got wrong size: %u\n", info_size);
fail_size = 0;
ret = WNetGetUniversalNameA(driveA, REMOTE_NAME_INFO_LEVEL,
buffer, &fail_size);
if(drive_type == DRIVE_REMOTE)
todo_wine
ok(ret == WN_BAD_VALUE || ret == WN_MORE_DATA, "WNetGetUniversalNameA failed: %08x\n", ret);
else
ok(ret == WN_NOT_CONNECTED || ret == WN_NO_NET_OR_BAD_PATH,
"(%s) WNetGetUniversalNameA gave wrong error: %u\n", driveA, ret);
ret = WNetGetUniversalNameA(driveA, REMOTE_NAME_INFO_LEVEL,
buffer, NULL);
todo_wine ok(ret == WN_BAD_POINTER, "WNetGetUniversalNameA failed: %08x\n", ret);
ret = WNetGetUniversalNameA(driveA, REMOTE_NAME_INFO_LEVEL,
NULL, &info_size);
if(drive_type == DRIVE_REMOTE)
todo_wine
ok(ret == WN_BAD_POINTER || ret == WN_BAD_VALUE, "WNetGetUniversalNameA failed: %08x\n", ret);
else
ok(ret == WN_NOT_CONNECTED || ret == WN_BAD_VALUE,
"(%s) WNetGetUniversalNameA gave wrong error: %u\n", driveA, ret);
fail_size = ARRAY_SIZE(driveA) - 1;
ret = WNetGetUniversalNameA(driveA, REMOTE_NAME_INFO_LEVEL,
buffer, &fail_size);
if(drive_type == DRIVE_REMOTE)
todo_wine ok(ret == WN_MORE_DATA, "WNetGetUniversalNameA failed: %08x\n", ret);
ret = WNetGetUniversalNameA(driveandpathA, REMOTE_NAME_INFO_LEVEL,
buffer, &info_size);
if(drive_type == DRIVE_REMOTE)
todo_wine ok(ret == WN_NO_ERROR, "WNetGetUniversalNameA failed: %08x\n", ret);
info_size = sizeof(buffer);
ret = WNetGetUniversalNameW(driveW, REMOTE_NAME_INFO_LEVEL,
buffer, &info_size);
todo_wine{
if(drive_type == DRIVE_REMOTE)
ok(ret == WN_NO_ERROR, "WNetGetUniversalNameW failed: %08x\n", ret);
else
ok(ret == WN_NOT_CONNECTED || ret == WN_NO_NET_OR_BAD_PATH,
"(%s) WNetGetUniversalNameW gave wrong error: %u\n", driveA, ret);
}
ok(info_size == sizeof(buffer), "Got wrong size: %u\n", info_size);
}
}
static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
LPCWSTR path, int depth, LPWSTR *appValue)
{
UINT rc;
DWORD attr;
LPWSTR val = NULL;
TRACE("%p, %p, %s, %d, %p\n", package, sig, debugstr_w(path), depth,
appValue);
if (ACTION_IsFullPath(path))
{
if (sig->File)
rc = ACTION_RecurseSearchDirectory(package, &val, sig, path, depth);
else
{
/* Recursively searching a directory makes no sense when the
* directory to search is the thing you're trying to find.
*/
rc = ACTION_CheckDirectory(package, path, &val);
}
}
else
{
WCHAR pathWithDrive[MAX_PATH] = { 'C',':','\\',0 };
DWORD drives = GetLogicalDrives();
int i;
rc = ERROR_SUCCESS;
for (i = 0; rc == ERROR_SUCCESS && !val && i < 26; i++)
{
if (!(drives & (1 << i)))
continue;
pathWithDrive[0] = 'A' + i;
if (GetDriveTypeW(pathWithDrive) != DRIVE_FIXED)
continue;
lstrcpynW(pathWithDrive + 3, path,
sizeof(pathWithDrive) / sizeof(pathWithDrive[0]) - 3);
if (sig->File)
rc = ACTION_RecurseSearchDirectory(package, &val, sig,
pathWithDrive, depth);
else
rc = ACTION_CheckDirectory(package, pathWithDrive, &val);
}
}
attr = GetFileAttributesW(val);
if (attr != INVALID_FILE_ATTRIBUTES &&
(attr & FILE_ATTRIBUTE_DIRECTORY) &&
val && val[lstrlenW(val) - 1] != '\\')
{
val = msi_realloc(val, (lstrlenW(val) + 2) * sizeof(WCHAR));
if (!val)
rc = ERROR_OUTOFMEMORY;
else
PathAddBackslashW(val);
}
*appValue = val;
TRACE("returning %d\n", rc);
return rc;
}
static void test_WNetGetUniversalName(void)
{
DWORD ret;
char buffer[1024];
DWORD drive_type, info_size, fail_size;
char driveA[] = "A:\\";
char driveandpathA[] = "A:\\file.txt";
WCHAR driveW[] = {'A',':','\\',0};
for(; *driveA <= 'Z'; ++*driveA, ++*driveandpathA, ++*driveW){
drive_type = GetDriveTypeW(driveW);
info_size = sizeof(buffer);
ret = WNetGetUniversalNameA(driveA, UNIVERSAL_NAME_INFO_LEVEL,
buffer, &info_size);
if(drive_type == DRIVE_REMOTE)
ok(ret == WN_NO_ERROR, "WNetGetUniversalNameA failed: %08x\n", ret);
else
/* WN_NO_NET_OR_BAD_PATH (DRIVE_FIXED) returned from the virtual drive (usual Q:)
created by the microsoft application virtualization client */
ok((ret == WN_NOT_CONNECTED) || (ret == WN_NO_NET_OR_BAD_PATH),
"WNetGetUniversalNameA(%s, ...) returned %u (drive_type: %u)\n",
driveA, ret, drive_type);
ok(info_size == sizeof(buffer), "Got wrong size: %u\n", info_size);
fail_size = 0;
ret = WNetGetUniversalNameA(driveA, UNIVERSAL_NAME_INFO_LEVEL,
buffer, &fail_size);
if(drive_type == DRIVE_REMOTE)
todo_wine ok(ret == WN_BAD_VALUE || ret == WN_MORE_DATA, "WNetGetUniversalNameA failed: %08x\n", ret);
else
ok(ret == WN_NOT_CONNECTED || ret == WN_NO_NET_OR_BAD_PATH,
"(%s) WNetGetUniversalNameW gave wrong error: %u\n", driveA, ret);
fail_size = ARRAY_SIZE(driveA) - 1;
ret = WNetGetUniversalNameA(driveA, UNIVERSAL_NAME_INFO_LEVEL,
buffer, &fail_size);
if(drive_type == DRIVE_REMOTE)
ok(ret == WN_MORE_DATA, "WNetGetUniversalNameA failed: %08x\n", ret);
ret = WNetGetUniversalNameA(driveandpathA, UNIVERSAL_NAME_INFO_LEVEL,
buffer, &info_size);
if(drive_type == DRIVE_REMOTE)
todo_wine ok(ret == WN_NO_ERROR, "WNetGetUniversalNameA failed: %08x\n", ret);
info_size = sizeof(buffer);
ret = WNetGetUniversalNameW(driveW, UNIVERSAL_NAME_INFO_LEVEL,
buffer, &info_size);
if(drive_type == DRIVE_REMOTE)
ok(ret == WN_NO_ERROR, "WNetGetUniversalNameW failed: %08x\n", ret);
else
ok((ret == WN_NOT_CONNECTED) || (ret == WN_NO_NET_OR_BAD_PATH),
"WNetGetUniversalNameW(%s, ...) returned %u (drive_type: %u)\n",
wine_dbgstr_w(driveW), ret, drive_type);
if(drive_type != DRIVE_REMOTE)
ok(info_size == sizeof(buffer), "Got wrong size: %u\n", info_size);
}
}
