/********************************************************************** * INT_Int11Handler (WPROCS.117) * * Handler for int 11h (get equipment list). */ void WINAPI INT_Int11Handler( CONTEXT86 *context ) { int diskdrives = 0; int parallelports = 0; int serialports = 0; int x; /* borrowed from Ralph Brown's interrupt lists bits 15-14: number of parallel devices bit 13: [Conv] Internal modem bit 12: reserved bits 11- 9: number of serial devices bit 8: reserved bits 7- 6: number of diskette drives minus one bits 5- 4: Initial video mode: 00b = EGA,VGA,PGA 01b = 40 x 25 color 10b = 80 x 25 color 11b = 80 x 25 mono bit 3: reserved bit 2: [PS] =1 if pointing device [non-PS] reserved bit 1: =1 if math co-processor bit 0: =1 if diskette available for boot */ /* Currently the only of these bits correctly set are: bits 15-14 } Added by William Owen Smith, bits 11-9 } [email protected] bits 7-6 bit 2 (always set) */ if (GetDriveTypeA("A:\\") == DRIVE_REMOVABLE) diskdrives++; if (GetDriveTypeA("B:\\") == DRIVE_REMOVABLE) diskdrives++; if (diskdrives) diskdrives--; for (x=0; x < 9; x++) { char temp[16],name[16]; sprintf(name,"COM%d",x+1); PROFILE_GetWineIniString("serialports",name,"*",temp,sizeof temp); if(strcmp(temp,"*")) serialports++; sprintf(name,"LPT%d",x+1); PROFILE_GetWineIniString("parallelports",name,"*",temp,sizeof temp); if(strcmp(temp,"*")) parallelports++; } if (serialports > 7) /* 3 bits -- maximum value = 7 */ serialports=7; if (parallelports > 3) /* 2 bits -- maximum value = 3 */ parallelports=3; AX_reg(context) = (diskdrives << 6) | (serialports << 9) | (parallelports << 14) | 0x02; }
/********************************************************************* * WNetGetDirectoryType [USER.530] Decides whether resource is local * * RETURNS * on success, puts one of the following in *lpType: * - WNDT_NETWORK on a network * - WNDT_LOCAL local */ WORD WINAPI WNetGetDirectoryType16( LPSTR lpName, LPINT16 lpType ) { UINT type = GetDriveTypeA(lpName); if ( type == DRIVE_NO_ROOT_DIR ) type = GetDriveTypeA(NULL); *lpType = (type == DRIVE_REMOTE)? WNDT_NETWORK : WNDT_NORMAL; TRACE( "%s is %s\n", debugstr_a(lpName), (*lpType == WNDT_NETWORK)? "WNDT_NETWORK" : "WNDT_NORMAL" ); return WN16_SUCCESS; }
/*! Returns a list of volume info objects that are mounted as network drive shares. */ QList<VolumeInfo> networkVolumeInfosFromMountPoints() { QList<VolumeInfo> volumes; QFileInfoList drives = QDir::drives(); foreach (const QFileInfo &drive, drives) { const QString driveLetter = QDir::toNativeSeparators(drive.canonicalPath()); const uint driveType = GetDriveTypeA(qPrintable(driveLetter)); switch (driveType) { case DRIVE_REMOTE: { char buffer[1024] = ""; DWORD bufferLength = 1024; UNIVERSAL_NAME_INFOA *universalNameInfo = (UNIVERSAL_NAME_INFOA*) &buffer; if (WNetGetUniversalNameA(qPrintable(driveLetter), UNIVERSAL_NAME_INFO_LEVEL, LPVOID(universalNameInfo), &bufferLength) == NO_ERROR) { VolumeInfo info; info.setMountPath(driveLetter); info.setVolumeDescriptor(QLatin1String(universalNameInfo->lpUniversalName)); volumes.append(info); } } break; default: break; } } return volumes; }
L004018EC( _unknown_ __eax // r0 ) { intOrPtr _v44; // _cfa_ffffffd4 _unknown_ __ebp; // r6 _unknown_ _t11; // _t11 _unknown_ _t13; // _t13 _unknown_ _t16; // _t16 _unknown_ _t17; // _t17 __ebx = 4208156; _push(4208156); L0040159C(__edi, _t13 + -1424449641, __eax, _t16, *((intOrPtr*)(__ebx + 276))); _pop(__ebx); GetDriveTypeA(0); _v44 = 3; while(_v44 != 0) { _v44 = _v44 - 1; asm("adc edi, [ebp-0x10]"); asm("sbb ecx, edx"); } _v44 = _v44 + __edi; __esi = __ebx + -1564; while(1) { asm("stc "); asm("invalid "); if(LoadLibraryA(__esi) == 0) { break; } } return; }
L004010B8() { /* unknown */ void Vffffff58; /* unknown */ void Vffffff5c; /* unknown */ void Vffffffa8; /* unknown */ void Vffffffcc; (save)eax + 392; (restore)edx; Vffffff58 = Vffffff58 & L004015A4(Vffffff5c, Vffffffa8); asm("sbb esi,-0x45"); (save)edx; GetForegroundWindow(); (restore)edx; for(*(edx + 156) = 0; *(edx + 156) != 3; asm("sbb ebx,-0x4e");) { *(edx + 156) = *(edx + 156) + 1; esi = esi - -102; } Vffffffcc = Vffffffcc + 26; *(edx + -360) = *(edx + -360) & -649021458; eax = GetDriveTypeA(0, edx); (restore)edx; }
L0040138C() { /* unknown */ void Vffffffb8; /* unknown */ void Vffffffd0; /* unknown */ void Vffffffdc; L0040138f: do { ecx = esi + 108; *(ecx + -256) = eax; if(ecx == 28070) { goto L0040138f; } GetCurrentThreadId(ecx); for(*(ecx + -508) = 5; *(ecx + -508) != 0; edx = edx & -1850285316) { *(ecx + -508) = *(ecx + -508) - 1; esi = 83; } (save)ecx; eax = L0040199C(Vffffffdc, Vffffffd0, *(ecx + 32), Vffffffb8); (restore)ecx; } while(ecx < 32338); *(ecx - 28) = *(ecx - 28) | edi; (save)ecx; return(GetDriveTypeA(0)); }
L004013FD() { *eax = *eax + al; *(ebx + -326412846) = *(ebx + -326412846) + cl; esp = esp - 192; esi = 0x4031ac; *(ebp - 80) = *(ebp - 80) & 0x4031ac; asm("adc eax,-0x57"); (save)0; eax = GetDriveTypeA(); for(*(ebp - 72) = 5; *(ebp - 72) != 0; *(esi + 316) = *(esi + 316) ^ 370344668) { *(ebp - 72) = *(ebp - 72) - 1; eax = eax - *(ebp - 92); } (save)esi; (save)eax; (save) *(esi + 324); (save) *(ebp - 64); (save) *(esi + 612); eax = L0040138C(); (restore)esi; asm("sbb ecx,ebx"); eax = eax ^ ecx; eax = *( *(esi + 120))(__imp__LoadLibraryA); (restore)ebp; }
L0040105C() { /* unknown */ void Vffffffd0; ebx = edx - 48; asm("adc edx,[ebp-0x28]"); (save)ebx; (save)esi; (save) *(ebx + 348); (save) *(ebx + 548); L00401000(); (restore)ebx; esi = esi - Vffffffd0; (save)0; GetDriveTypeA(); edi = 4; do { *(ebx + -140) = *(ebx + -140) & -55620853; edx = edi; edi = edi - 1; } while(edi != 0); asm("adc [ebx-0x3c],edx"); edi = edi + *(ebx + 128); return(GetForegroundWindow()); }
L004018CC() { /* unknown */ void Vffffff5c; /* unknown */ void Vffffff9c; /* unknown */ void Vffffffb0; esi = ecx + 532; *(esi + 72) = *(esi + 72) | -121; (save)esi; (save)ebx; (save)ebx; (save) *(esi + 152); (save) *(esi + 348); L00401528(); (restore)esi; edi = edi & Vffffff9c; GetActiveWindow(); Vffffffb0 = 3; do { asm("adc [esi+0xfffffeb8],ebx"); asm("adc [ebp+0xffffff74],edi"); Vffffffb0 = Vffffffb0 - 1; } while(Vffffffb0 != 0); Vffffff5c = Vffffff5c + 1101831121; *(esi - 48) = *(esi - 48) | ebx; return(GetDriveTypeA(0)); }
BOOL IsPathCdrom(const char *path) { if (GetDriveTypeA(cdrompath) == DRIVE_CDROM) return TRUE; else return FALSE; }
/******************************************************************** * 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; } }
void WINAPI RunDLL_SaveImageFile(HWND hWnd, HINSTANCE hInst, LPSTR lpszCmdLine, int nCmdShow) { WCHAR file_name[MAX_PATH + 1] = L""; WCHAR mount_point[] = L"\\\\.\\ :"; HANDLE hDev; BOOL bIsCdRomType = FALSE; switch (GetDriveTypeA(lpszCmdLine)) { case DRIVE_CDROM: bIsCdRomType = TRUE; break; case DRIVE_REMOTE: MsgBoxPrintF(hWnd, MB_ICONSTOP, L"ImDisk Virtual Disk Driver", L"Unsupported drive type: '%1!hs!'", lpszCmdLine); return; } // If user right-clicked in Windows Explorer the drive we are dismounting is // the current directory in this process. Change to Windows directory. if (GetWindowsDirectory(file_name, sizeof(file_name) / sizeof(*file_name))) { file_name[(sizeof(file_name) / sizeof(*file_name)) - 1] = 0; SetCurrentDirectory(file_name); } file_name[0] = 0; if (strlen(lpszCmdLine) < 2 ? TRUE : lpszCmdLine[1] != L':') { MsgBoxPrintF(hWnd, MB_ICONSTOP, L"ImDisk Virtual Disk Driver", L"Unsupported mount point: '%1!hs!'", lpszCmdLine); return; } mount_point[4] = lpszCmdLine[0]; hDev = CreateFile(mount_point, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_SEQUENTIAL_SCAN, NULL); if (hDev == INVALID_HANDLE_VALUE) { MsgBoxLastError(hWnd, L"Cannot open drive for direct access:"); return; } ImDiskSaveImageFileInteractive(hDev, hWnd, 0, bIsCdRomType); CloseHandle(hDev); }
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); }
BOOL My_GetDriveTypeA() { LPCSTR lpRootPathName=NULL; UINT returnVal_Real = NULL; UINT returnVal_Intercepted = NULL; DWORD error_Real = 0; DWORD error_Intercepted = 0; __try{ disableInterception(); returnVal_Real = GetDriveTypeA (lpRootPathName); error_Real = GetLastError(); enableInterception(); returnVal_Intercepted = GetDriveTypeA (lpRootPathName); error_Intercepted = GetLastError(); }__except(puts("in filter"), 1){puts("exception caught");} return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted)); }
/********************************************************************** * DOSVM_Int11Handler * * Handler for int 11h (get equipment list). * * * Borrowed from Ralph Brown's interrupt lists: * * bits 15-14: number of parallel devices * bit 13: [Conv] Internal modem * bit 12: reserved * bits 11- 9: number of serial devices * bit 8: reserved * bits 7- 6: number of diskette drives minus one * bits 5- 4: Initial video mode: * 00b = EGA,VGA,PGA * 01b = 40 x 25 color * 10b = 80 x 25 color * 11b = 80 x 25 mono * bit 3: reserved * bit 2: [PS] =1 if pointing device * [non-PS] reserved * bit 1: =1 if math co-processor * bit 0: =1 if diskette available for boot * * * Currently the only of these bits correctly set are: * * bits 15-14 } Added by William Owen Smith, * bits 11-9 } [email protected] * bits 7-6 * bit 2 (always set) ( bit 2 = 4 ) * bit 1 } Robert 'Admiral' Coeyman * All *nix systems either have a math processor or * emulate one. */ static void WINAPI DOSVM_Int11Handler( CONTEXT86 *context ) { int diskdrives = 0; int parallelports = 0; int serialports = 0; int x; if (GetDriveTypeA("A:\\") == DRIVE_REMOVABLE) diskdrives++; if (GetDriveTypeA("B:\\") == DRIVE_REMOVABLE) diskdrives++; if (diskdrives) diskdrives--; for (x=0; x < 9; x++) { HANDLE handle; char file[10]; /* serial port name */ sprintf( file, "\\\\.\\COM%d", x+1 ); handle = CreateFileA( file, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 ); if (handle != INVALID_HANDLE_VALUE) { CloseHandle( handle ); serialports++; } sprintf( file, "\\\\.\\LPT%d", x+1 ); handle = CreateFileA( file, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 ); if (handle != INVALID_HANDLE_VALUE) { CloseHandle( handle ); parallelports++; } } if (serialports > 7) /* 3 bits -- maximum value = 7 */ serialports = 7; if (parallelports > 3) /* 2 bits -- maximum value = 3 */ parallelports = 3; SET_AX( context, (diskdrives << 6) | (serialports << 9) | (parallelports << 14) | 0x06 ); }
unsigned long ntfs::VolOps::getDriveType() { std::string volname; std::tie(volname, std::ignore, std::ignore) = getVolInfo(); return GetDriveTypeA(volname.c_str()); }
bool Win32AudioCDManager::tryAddDrive(char drive, DriveList &drives) { Common::String drivePath = Common::String::format("%c:\\", drive); // Ensure it's an actual CD drive if (GetDriveTypeA(drivePath.c_str()) != DRIVE_CDROM) return false; debug(2, "Detected drive %c:\\ as a CD drive", drive); drives.push_back(drive); return true; }
bool IsRemovable(const char *Name) { #ifdef _WIN_ALL char Root[NM]; GetPathRoot(Name,Root); int Type=GetDriveTypeA(*Root!=0 ? Root:NULL); return(Type==DRIVE_REMOVABLE || Type==DRIVE_CDROM); #elif defined(_EMX) char Drive=etoupper(Name[0]); return((Drive=='A' || Drive=='B') && Name[1]==':'); #else return(false); #endif }
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; } }
bool FileSystem::isRemoteFS( const std::string& directory ) { if ((directory[0] == '\\' || directory[0] == '/') && (directory[1] == '\\' || directory[1] == '/')) { return true; } if ( directory.size() >= 3 ) { return 4 == GetDriveTypeA( directory.substr( 0, 3 ).c_str() ); } return false; }
std::vector<std::string> CrossPlatform::getCdDrivePaths() { std::vector<std::string> result; #if defined(_WIN32) || defined(WIN32) // Looking for data files on CD-ROM drives char buf[256]; GetLogicalDriveStringsA(sizeof(buf), buf); for(char * s = buf; *s; s += strlen(s) + 1) { if (GetDriveTypeA(s) == DRIVE_CDROM) { result.push_back(std::string(s)); } } #elif defined(__unix__) FILE *mtab = setmntent("/etc/mtab", "r"); struct mntent *m; struct mntent mnt; char strings[4096]; while ((m = getmntent_r(mtab, &mnt, strings, sizeof(strings)))) { std::string directory = mnt.mnt_dir; std::string type = mnt.mnt_type; if (type == "iso9660") { result.push_back(directory); } } endmntent(mtab); #elif defined (__APPLE__) struct statfs *mntbuf; int mntsize = getmntinfo(&mntbuf, MNT_NOWAIT); for ( int i = 0; i < mntsize; i++ ) { std::string directory = ((struct statfs *)&mntbuf[i])->f_mntonname; std::string type = ((struct statfs *)&mntbuf[i])->f_fstypename; if (type == "cd9660") { result.push_back(directory); } } #else throw Exception("CD-ROM detection not supported"); #endif return result; }
HRESULT CDrivesExtractIcon_CreateInstance(IShellFolder * psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID * ppvOut) { CComPtr<IDefaultExtractIconInit> initIcon; HRESULT hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit, &initIcon)); if (FAILED_UNEXPECTEDLY(hr)) return hr; CHAR* pszDrive = _ILGetDataPointer(pidl)->u.drive.szDriveName; WCHAR wTemp[MAX_PATH]; int icon_idx = -1; if (pszDrive) { switch(GetDriveTypeA(pszDrive)) { case DRIVE_REMOVABLE: icon_idx = IDI_SHELL_3_14_FLOPPY; break; case DRIVE_CDROM: icon_idx = IDI_SHELL_CDROM; break; case DRIVE_REMOTE: icon_idx = IDI_SHELL_NETDRIVE; break; case DRIVE_RAMDISK: icon_idx = IDI_SHELL_RAMDISK; break; case DRIVE_NO_ROOT_DIR: icon_idx = IDI_SHELL_CDROM; break; } } if (icon_idx != -1) { initIcon->SetNormalIcon(swShell32Name, -icon_idx); } else { if (HCR_GetIconW(L"Drive", wTemp, NULL, MAX_PATH, &icon_idx)) initIcon->SetNormalIcon(wTemp, icon_idx); else initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_DRIVE); } return initIcon->QueryInterface(riid, ppvOut); }
/*********************************************************************** * DriveType (SHELL.262) */ UINT16 WINAPI DriveType16( UINT16 drive ) { UINT ret; char path[] = "A:\\"; path[0] += drive; ret = GetDriveTypeA(path); switch(ret) /* some values are not supported in Win16 */ { case DRIVE_CDROM: ret = DRIVE_REMOTE; break; case DRIVE_NO_ROOT_DIR: ret = DRIVE_UNKNOWN; break; } return ret; }
EIF_BOOLEAN eif_is_volume_name_valid(EIF_CHARACTER_8* p) { #ifdef EIF_WINDOWS char rootpath[4]; if (p) if ((strlen((char*)p) == 2) && (*(p+1) == ':')) { strncpy((char*)rootpath, (char*)p, 2); rootpath[2] = '\\'; rootpath [3] = '\0'; return (EIF_BOOLEAN)(GetDriveTypeA(rootpath) != 1); } return EIF_FALSE; #else /* Unix */ return (EIF_BOOLEAN)(*p == '\0'); #endif }
/*********************************************************************** * GetTempFileName (KERNEL.97) */ UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique, LPSTR buffer ) { char temppath[MAX_PATH]; char *prefix16 = NULL; UINT16 ret; if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */ { GetCurrentDirectoryA(sizeof(temppath), temppath); drive |= temppath[0]; } if (drive & TF_FORCEDRIVE) { char d[3]; d[0] = drive & ~TF_FORCEDRIVE; d[1] = ':'; d[2] = '\0'; if (GetDriveTypeA(d) == DRIVE_NO_ROOT_DIR) { drive &= ~TF_FORCEDRIVE; WARN("invalid drive %d specified\n", drive ); } } if (drive & TF_FORCEDRIVE) sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE ); else GetTempPathA( MAX_PATH, temppath ); if (prefix) { prefix16 = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + 2); *prefix16 = '~'; strcpy(prefix16 + 1, prefix); } ret = GetTempFileNameA( temppath, prefix16, unique, buffer ); HeapFree(GetProcessHeap(), 0, prefix16); return ret; }
INT APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT iCmdShow ) { // 创建C盘下的目标文件夹 CreateDirectoryA(szTmpPath, NULL); char szBuf[100]; ZeroMemory(szBuf, sizeof(szBuf)); while (TRUE) { Sleep(5000); // 获得当前磁盘等驱动器信息 DWORD len = GetLogicalDriveStringsA(sizeof(szBuf), szBuf); for (char *pDrive = szBuf; *pDrive != NULL; pDrive += strlen(pDrive)+1) { char *pDrivePath = pDrive; // 获取驱动器类型信息,简单起见,不区分软驱和U盘(目标机器没有软驱...) if (GetDriveTypeA(pDrivePath) ==DRIVE_REMOVABLE) { #ifdef MY_DEBUG char szShow[50] = "发现U盘,位于 "; strcat(szShow, pDrivePath); MessageBoxA(NULL, szShow, "信息", MB_OK); #endif FindDocFile(pDrivePath); } } // 获取桌面路径 LPITEMIDLIST pidl; char szDesktopDir[MAX_PATH]; if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl))) { SHGetPathFromIDListA(pidl, szDesktopDir); } strcat(szDesktopDir, "\\"); // 拷贝桌面的文档 FindDocFile(szDesktopDir); } return 0; }
static void test_cdrom_ioctl(void) { char drive_letter, drive_path[] = "A:\\", drive_full_path[] = "\\\\.\\A:"; DWORD bitmask; HANDLE handle; bitmask = GetLogicalDrives(); if(!bitmask) { trace("GetLogicalDrives failed : %u\n", GetLastError()); return; } for(drive_letter='A'; drive_letter<='Z'; drive_letter++) { if(!(bitmask & (1 << (drive_letter-'A') ))) continue; drive_path[0] = drive_letter; if(GetDriveTypeA(drive_path) != DRIVE_CDROM) { trace("Skipping %c:, not a CDROM drive.\n", drive_letter); continue; } trace("Testing with %c:\n", drive_letter); drive_full_path[4] = drive_letter; handle = CreateFileA(drive_full_path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0); if(handle == INVALID_HANDLE_VALUE) { trace("Failed to open the device : %u\n", GetLastError()); continue; } /* Add your tests here */ test_dvd_read_structure(handle); CloseHandle(handle); } }
DiskMuninNodePlugin::DiskMuninNodePlugin() { int i; for (i = 0; i < 32; i++) { drives[i][0] = NULL; } i = 0; for (int d = 'A'; d <= 'Z'; d++) { drives[i][0] = d; drives[i][1] = ':'; drives[i][2] = NULL;//'\\'; drives[i][3] = NULL; if (GetDriveTypeA(drives[i]) != DRIVE_FIXED) { // Remove it drives[i][0] = NULL; } else { i++; } } }
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 */
void XFileFinder::GetDriverList(XString8Array &drivers, XString8Array &names) { int drives=GetLogicalDrives(); int nums=0; drives>>=2; XTCHAR disk[]="C:\\"; XString8 strName="(C:)"; while(drives) { if(drives&0x01) { // UINT type=GetDriveType(disk); UINT type=GetDriveTypeA(disk); XTCHAR buf[64]; DWORD s; // ::GetVolumeInformation(disk,buf,64,&s,&s,&s,XNULL,0); ::GetVolumeInformationA(disk,buf,64,&s,&s,&s,XNULL,0); if(type!=DRIVE_CDROM) { drivers.Add(disk); XString8 str; if((type==DRIVE_REMOVABLE)&&buf[0]==0) { str=XResource::LoadWString(XIDS_REMOVEBLEDISK); //"���ƶ���"; } else str=buf; strName[1]=disk[0]; str+=strName; names.Add(str); } } disk[0]++; drives>>=1; } }