Changeset 30365 in vbox for trunk/src/VBox/Runtime/r3

Timestamp:

Jun 22, 2010 12:08:20 PM (15 years ago)

Author:

vboxsync

Message:

RTFsQueryType: Use an enum. Added RTFsTypeName() for translating a enum value into a string. Added more file system types.

Location:

trunk/src/VBox/Runtime/r3

Files:

• fs.cpp (modified) (3 diffs)
• posix/fs-posix.cpp (modified) (6 diffs)
• win/fs-win.cpp (modified) (1 diff)

trunk/src/VBox/Runtime/r3/fs.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2010 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -40 +40 @@
 
 #include <iprt/fs.h>
+#include "internal/iprt.h"
+
+#include <iprt/asm.h>
 #include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
 #include <iprt/time.h>
-#include <iprt/string.h>
-#include <iprt/path.h>
-#include <iprt/ctype.h>
 #include "internal/fs.h"
 
@@ -292 +295 @@
     pObjInfo->Attr.u.Unix.Device          = pStat->st_rdev;
 }
-
 #endif /* !RT_OS_WINDOWS */
+
+
+RTDECL(const char *) RTFsTypeName(RTFSTYPE enmType)
+{
+    switch (enmType)
+    {
+        case RTFSTYPE_UNKNOWN:      return "unknown";
+        case RTFSTYPE_UDF:          return "udf";
+        case RTFSTYPE_ISO9660:      return "iso9660";
+        case RTFSTYPE_FUSE:         return "fuse";
+        case RTFSTYPE_VBOXSHF:      return "vboxshf";
+
+        case RTFSTYPE_EXT:          return "ext";
+        case RTFSTYPE_EXT2:         return "ext2";
+        case RTFSTYPE_EXT3:         return "ext3";
+        case RTFSTYPE_EXT4:         return "ext4";
+        case RTFSTYPE_XFS:          return "xfs";
+        case RTFSTYPE_CIFS:         return "cifs";
+        case RTFSTYPE_SMBFS:        return "smbfs";
+        case RTFSTYPE_TMPFS:        return "tmpfs";
+        case RTFSTYPE_SYSFS:        return "sysfs";
+        case RTFSTYPE_PROC:         return "proc";
+
+        case RTFSTYPE_NTFS:         return "ntfs";
+        case RTFSTYPE_FAT:          return "fat";
+
+        case RTFSTYPE_ZFS:          return "zfs";
+        case RTFSTYPE_UFS:          return "ufs";
+        case RTFSTYPE_NFS:          return "nfs";
+
+        case RTFSTYPE_HFS:          return "hfs";
+        case RTFSTYPE_AUTOFS:       return "autofs";
+        case RTFSTYPE_DEVFS:        return "devfs";
+
+        case RTFSTYPE_HPFS:         return "hpfs";
+        case RTFSTYPE_JFS:          return "jfs";
+
+        case RTFSTYPE_END:          return "end";
+        case RTFSTYPE_32BIT_HACK:   break;
+    }
+
+    /* Don't put this in as 'default:', we wish GCC to warn about missing cases. */
+    static char                 s_asz[4][64];
+    static uint32_t volatile    s_i = 0;
+    uint32_t i = ASMAtomicIncU32(&s_i) % RT_ELEMENTS(s_asz);
+    RTStrPrintf(s_asz[i], sizeof(s_asz[i]), "type=%d", enmType);
+    return s_asz[i];
+}
+

trunk/src/VBox/Runtime/r3/posix/fs-posix.cpp

@@ -171 +171 @@
 
 
-RTR3DECL(int) RTFsQueryType(const char *pszFsPath, uint32_t *pu32Type)
-{
+RTR3DECL(int) RTFsQueryType(const char *pszFsPath, PRTFSTYPE penmType)
+{
+    *penmType = RTFSTYPE_UNKNOWN;
+
     /*
      * Validate input.
      */
-    AssertMsgReturn(VALID_PTR(pszFsPath) && *pszFsPath, ("%p", pszFsPath), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFsPath, VERR_INVALID_POINTER);
+    AssertReturn(*pszFsPath, VERR_INVALID_PARAMETER);
 
     /*
@@ -186 +189 @@
     if (RT_SUCCESS(rc))
     {
-        *pu32Type = RTFS_FS_TYPE_UNKNOWN;
-
         struct stat Stat;
         if (!stat(pszNativeFsPath, &Stat))
@@ -197 +198 @@
             if (mounted)
             {
-                char szBuf[1024];
-                struct stat mntStat;
-                struct mntent mntEnt;
+                char            szBuf[1024];
+                struct stat     mntStat;
+                struct mntent   mntEnt;
                 while (getmntent_r(mounted, &mntEnt, szBuf, sizeof(szBuf)))
                 {
@@ -207 +208 @@
                         {
                             if (!strcmp("ext4", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_EXT4;
+                                *penmType = RTFSTYPE_EXT4;
                             else if (!strcmp("ext3", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_EXT3;
+                                *penmType = RTFSTYPE_EXT3;
                             else if (!strcmp("ext2", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_EXT2;
+                                *penmType = RTFSTYPE_EXT2;
+                            else if (!strcmp("jfs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_JFS;
                             else if (!strcmp("xfs", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_XFS;
+                                *penmType = RTFSTYPE_XFS;
                             else if (   !strcmp("vfat", mntEnt.mnt_type)
                                      || !strcmp("msdos", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_FAT;
+                                *penmType = RTFSTYPE_FAT;
+                            else if (!strcmp("ntfs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_NTFS;
+                            else if (!strcmp("hpfs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_HPFS;
+                            else if (!strcmp("ufs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_UFS;
                             else if (!strcmp("tmpfs", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_TMPFS;
+                                *penmType = RTFSTYPE_TMPFS;
                             else if (!strcmp("hfsplus", mntEnt.mnt_type))
-                                *pu32Type = RTFS_FS_TYPE_HFS;
+                                *penmType = RTFSTYPE_HFS;
+                            else if (!strcmp("udf", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_UDF;
+                            else if (!strcmp("iso9660", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_ISO9660;
+                            else if (!strcmp("smbfs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_SMBFS;
+                            else if (!strcmp("cifs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_CIFS;
+                            else if (!strcmp("nfs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_NFS;
+                            else if (!strcmp("nfs4", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_NFS;
+                            else if (!strcmp("sysfs", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_SYSFS;
+                            else if (!strcmp("proc", mntEnt.mnt_type))
+                                *penmType = RTFSTYPE_PROC;
+                            else if (   !strcmp("fuse", mntEnt.mnt_type)
+                                     || !strncmp("fuse.", mntEnt.mnt_type, 5))
+                                *penmType = RTFSTYPE_FUSE;
                             else
                             {
@@ -232 +260 @@
                 endmntent(mounted);
             }
+
 #elif defined(RT_OS_SOLARIS)
             if (!strcmp("zfs", Stat.st_fstype))
-                *pu32Type = RTFS_FS_TYPE_ZFS;
+                *penmType = RTFSTYPE_ZFS;
+            else if (!strcmp("ufs", Stat.st_fstype))
+                *penmType = RTFSTYPE_UFS;
+            else if (!strcmp("nfs", Stat.st_fstype))
+                *penmType = RTFSTYPE_NFS;
+
 #elif defined(RT_OS_DARWIN)
             struct statfs statfsBuf;
@@ -240 +274 @@
             {
                 if (!strcmp("hfs", statfsBuf.f_fstypename))
-                    *pu32Type = RTFS_FS_TYPE_HFS;
+                    *penmType = RTFSTYPE_HFS;
                 else if (   !strcmp("fat", statfsBuf.f_fstypename)
                          || !strcmp("msdos", statfsBuf.f_fstypename))
-                    *pu32Type = RTFS_FS_TYPE_FAT;
+                    *penmType = RTFSTYPE_FAT;
                 else if (!strcmp("ntfs", statfsBuf.f_fstypename))
-                    *pu32Type = RTFS_FS_TYPE_NTFS;
+                    *penmType = RTFSTYPE_NTFS;
                 else if (!strcmp("autofs", statfsBuf.f_fstypename))
-                    *pu32Type = RTFS_FS_TYPE_AUTOFS;
+                    *penmType = RTFSTYPE_AUTOFS;
                 else if (!strcmp("devfs", statfsBuf.f_fstypename))
-                    *pu32Type = RTFS_FS_TYPE_DEVFS;
+                    *penmType = RTFSTYPE_DEVFS;
                 else if (!strcmp("nfs", statfsBuf.f_fstypename))
-                    *pu32Type = RTFS_FS_TYPE_NFS;
+                    *penmType = RTFSTYPE_NFS;
             }
             else

trunk/src/VBox/Runtime/r3/win/fs-win.cpp

@@ -334 +334 @@
 }
 
-RTR3DECL(int) RTFsQueryType(const char *pszFsPath, uint32_t *pu32Type)
-{
-    int rc = VINF_SUCCESS;
-
-    *pu32Type = RTFS_FS_TYPE_UNKNOWN;
-
-    HANDLE hFile = CreateFile(pszFsPath,
-                              GENERIC_READ,
-                              FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                              NULL,
-                              OPEN_EXISTING,
-                              FILE_FLAG_BACKUP_SEMANTICS,
-                              NULL);
-    if (hFile != INVALID_HANDLE_VALUE)
-    {
-        char abBuf[8192];
-        IO_STATUS_BLOCK Ios;
-        NTSTATUS rcNt = NtQueryVolumeInformationFile(hFile, &Ios,
-                                                     abBuf, sizeof(abBuf),
-                                                     FileFsAttributeInformation);
-        if (rcNt >= 0)
-        {
-            PFILE_FS_ATTRIBUTE_INFORMATION pFsAttrInfo = (PFILE_FS_ATTRIBUTE_INFORMATION)abBuf;
-            if (   pFsAttrInfo->FileSystemName[0] == 'N'
-                && pFsAttrInfo->FileSystemName[1] == 'T'
-                && pFsAttrInfo->FileSystemName[2] == 'F'
-                && pFsAttrInfo->FileSystemName[3] == 'S'
-                && pFsAttrInfo->FileSystemName[4] == '\0')
-                *pu32Type = RTFS_FS_TYPE_NTFS;
-            else if (   pFsAttrInfo->FileSystemName[0] == 'F'
-                     && pFsAttrInfo->FileSystemName[1] == 'A'
-                     && pFsAttrInfo->FileSystemName[2] == 'T'
-                     && (   (   pFsAttrInfo->FileSystemName[3] == '3'
-                             && pFsAttrInfo->FileSystemName[4] == '2'
-                             && pFsAttrInfo->FileSystemName[5] == '\0')
-                         || pFsAttrInfo->FileSystemName[3] == '\0'))
-                /* This is either FAT32 or FAT12/16. IMO it doesn't make
-                 * sense to distinguish more detailed because we cannot
-                 * easily distinguish between these FAT types on Linux
-                 * and users who put some image file on an FAT16 partition
-                 * should know what they are doing. */
-                *pu32Type = RTFS_FS_TYPE_FAT;
+
+/**
+ * Internal helper for comparing a WCHAR string with a char string.
+ *
+ * @returns 0 if equal, -1 if @a psz1 < @a psz2, 1 if @a psz1 < @a psz2.
+ * @param   pwsz1               The first string.
+ * @param   psz2                The second string.
+ */
+static int rtFsWinCmpUtf16(WCHAR const *pwsz1, const char *psz2)
+{
+    for (;;)
+    {
+        unsigned ch1 = *pwsz1++;
+        unsigned ch2 = (unsigned char)*psz2++;
+        if (ch1 != ch2)
+            return ch1 < ch2 ? -1 : 1;
+        if (!ch1)
+            return 0;
+    }
+}
+
+
+RTR3DECL(int) RTFsQueryType(const char *pszFsPath, PRTFSTYPE penmType)
+{
+    *penmType = RTFSTYPE_UNKNOWN;
+
+    AssertPtrReturn(pszFsPath, VERR_INVALID_POINTER);
+    AssertReturn(*pszFsPath, VERR_INVALID_PARAMETER);
+
+    /*
+     * Convert the path and try open it.
+     */
+    PRTUTF16 pwszFsPath;
+    int rc = RTStrToUtf16(pszFsPath, &pwszFsPath);
+    if (RT_SUCCESS(rc))
+    {
+        HANDLE hFile = CreateFileW(pwszFsPath,
+                                   GENERIC_READ,
+                                   FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                   NULL,
+                                   OPEN_EXISTING,
+                                   FILE_FLAG_BACKUP_SEMANTICS,
+                                   NULL);
+        if (hFile != INVALID_HANDLE_VALUE)
+        {
+            /*
+             * Use the NT api directly to get the file system name.
+             */
+            char            abBuf[8192];
+            IO_STATUS_BLOCK Ios;
+            NTSTATUS        rcNt = NtQueryVolumeInformationFile(hFile, &Ios,
+                                                                abBuf, sizeof(abBuf),
+                                                                FileFsAttributeInformation);
+            if (rcNt >= 0)
+            {
+                PFILE_FS_ATTRIBUTE_INFORMATION pFsAttrInfo = (PFILE_FS_ATTRIBUTE_INFORMATION)abBuf;
+
+                if (!rtFsWinCmpUtf16(pFsAttrInfo->FileSystemName, "NTFS"))
+                    *penmType = RTFSTYPE_NTFS;
+                else if (!rtFsWinCmpUtf16(pFsAttrInfo->FileSystemName, "FAT"))
+                    *penmType = RTFSTYPE_FAT;
+                else if (!rtFsWinCmpUtf16(pFsAttrInfo->FileSystemName, "FAT32"))
+                    *penmType = RTFSTYPE_FAT;
+                else if (!rtFsWinCmpUtf16(pFsAttrInfo->FileSystemName, "VBoxSharedFolderFS"))
+                    *penmType = RTFSTYPE_VBOXSHF;
+            }
+            else
+                rc = RTErrConvertFromNtStatus(rcNt);
+            CloseHandle(hFile);
         }
-        /* else: Is RTFS_FS_UNKNOWN suffient or should we return an error? */
-        CloseHandle(hFile);
-    }
-
+        else
+            rc = RTErrConvertFromWin32(GetLastError());
+        RTUtf16Free(pwszFsPath);
+    }
     return rc;
 }