/********************************************************************** * 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); } }