VirtualBox

Ignore:
Timestamp:
Nov 12, 2010 12:15:05 AM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
67680
Message:

iprt: try split out some of the RTPathQueryInfo* dependent bits into separate files in the posix world.

File:
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/r3/posix/fs2-posix.cpp

    r34013 r34015  
    11/* $Id$ */
    22/** @file
    3  * IPRT - File System.
     3 * IPRT - File System Helpers, POSIX, Part 2.
    44 */
    55
    … …  
    2929*   Header Files                                                               *
    3030*******************************************************************************/
    31 #ifndef RT_OS_WINDOWS
    32 # define RTTIME_INCL_TIMESPEC
    33 # include <sys/time.h>
    34 # include <sys/param.h>
    35 # ifndef DEV_BSIZE
    36 #  include <sys/stat.h>
    37 #  define DEV_BSIZE S_BLKSIZE /** @todo bird: add DEV_BSIZE to sys/param.h on OS/2. */
    38 # endif
    39 # include <grp.h>
    40 # include <pwd.h>
     31#define RTTIME_INCL_TIMESPEC
     32#include <sys/time.h>
     33#include <sys/param.h>
     34#ifndef DEV_BSIZE
     35# include <sys/stat.h>
     36# define DEV_BSIZE S_BLKSIZE /** @todo bird: add DEV_BSIZE to sys/param.h on OS/2. */
    4137#endif
    4238
    … …  
    4440#include "internal/iprt.h"
    4541
    46 #include <iprt/asm.h>
    4742#include <iprt/assert.h>
    48 #include <iprt/ctype.h>
    49 #include <iprt/path.h>
    50 #include <iprt/string.h>
    5143#include <iprt/time.h>
    5244#include "internal/fs.h"
    5345
    54 
    55 /**
    56  * Converts dos-style attributes to Unix attributes.
    57  *
    58  * @returns
    59  * @param   fMode       The mode mask containing dos-style attributes only.
    60  * @param   pszName     The filename which this applies to (exe check).
    61  * @param   cbName      The length of that filename. (optional, set 0)
    62  */
    63 RTFMODE rtFsModeFromDos(RTFMODE fMode, const char *pszName, size_t cbName)
    64 {
    65     fMode &= ~((1 << RTFS_DOS_SHIFT) - 1);
    66 
    67     /* everything is readable. */
    68     fMode |= RTFS_UNIX_IRUSR | RTFS_UNIX_IRGRP | RTFS_UNIX_IROTH;
    69     if (fMode & RTFS_DOS_DIRECTORY)
    70         /* directories are executable. */
    71         fMode |= RTFS_TYPE_DIRECTORY | RTFS_UNIX_IXUSR | RTFS_UNIX_IXGRP | RTFS_UNIX_IXOTH;
    72     else
    73     {
    74         fMode |= RTFS_TYPE_FILE;
    75         if (!cbName && pszName)
    76             cbName = strlen(pszName);
    77         if (cbName >= 4 && pszName[cbName - 4] == '.')
    78         {
    79             /* check for executable extension. */
    80             const char *pszExt = &pszName[cbName - 3];
    81             char szExt[4];
    82             szExt[0] = RT_C_TO_LOWER(pszExt[0]);
    83             szExt[1] = RT_C_TO_LOWER(pszExt[1]);
    84             szExt[2] = RT_C_TO_LOWER(pszExt[2]);
    85             szExt[3] = '\0';
    86             if (    !memcmp(szExt, "exe", 4)
    87                 ||  !memcmp(szExt, "bat", 4)
    88                 ||  !memcmp(szExt, "com", 4)
    89                 ||  !memcmp(szExt, "cmd", 4)
    90                 ||  !memcmp(szExt, "btm", 4)
    91                )
    92                 fMode |= RTFS_UNIX_IXUSR | RTFS_UNIX_IXGRP | RTFS_UNIX_IXOTH;
    93         }
    94     }
    95 
    96     /* Is it really a symbolic link? */
    97     if (fMode & RTFS_DOS_NT_REPARSE_POINT)
    98         fMode = (fMode & ~RTFS_TYPE_MASK) | RTFS_TYPE_SYMLINK;
    99 
    100     /* writable? */
    101     if (!(fMode & RTFS_DOS_READONLY))
    102         fMode |= RTFS_UNIX_IWUSR | RTFS_UNIX_IWGRP | RTFS_UNIX_IWOTH;
    103     return fMode;
    104 }
    105 
    106 
    107 /**
    108  * Converts Unix attributes to Dos-style attributes.
    109  *
    110  * @returns File mode mask.
    111  * @param   fMode       The mode mask containing dos-style attributes only.
    112  * @param   pszName     The filename which this applies to (hidden check).
    113  * @param   cbName      The length of that filename. (optional, set 0)
    114  */
    115 RTFMODE rtFsModeFromUnix(RTFMODE fMode, const char *pszName, size_t cbName)
    116 {
    117     fMode &= RTFS_UNIX_MASK;
    118 
    119     if (!(fMode & (RTFS_UNIX_IWUSR | RTFS_UNIX_IWGRP | RTFS_UNIX_IWOTH)))
    120         fMode |= RTFS_DOS_READONLY;
    121     if (RTFS_IS_DIRECTORY(fMode))
    122         fMode |= RTFS_DOS_DIRECTORY;
    123     if (!(fMode & RTFS_DOS_MASK))
    124         fMode |= RTFS_DOS_NT_NORMAL;
    125     if (!(fMode & RTFS_DOS_HIDDEN) && pszName)
    126     {
    127         pszName = RTPathFilename(pszName);
    128         if (pszName && *pszName == '.')
    129             fMode |= RTFS_DOS_HIDDEN;
    130     }
    131     return fMode;
    132 }
    133 
    134 
    135 /**
    136  * Normalizes the give mode mask.
    137  *
    138  * It will create the missing unix or dos mask from the other (one
    139  * of them is required by all APIs), and guess the file type if that's
    140  * missing.
    141  *
    142  * @returns Normalized file mode.
    143  * @param   fMode       The mode mask that may contain a partial/incomplete mask.
    144  * @param   pszName     The filename which this applies to (exe check).
    145  * @param   cbName      The length of that filename. (optional, set 0)
    146  */
    147 RTFMODE rtFsModeNormalize(RTFMODE fMode, const char *pszName, size_t cbName)
    148 {
    149     if (!(fMode & RTFS_UNIX_MASK))
    150         fMode = rtFsModeFromDos(fMode, pszName, cbName);
    151     else if (!(fMode & RTFS_DOS_MASK))
    152         fMode = rtFsModeFromUnix(fMode, pszName, cbName);
    153     else if (!(fMode & RTFS_TYPE_MASK))
    154         fMode |= fMode & RTFS_DOS_DIRECTORY ? RTFS_TYPE_DIRECTORY : RTFS_TYPE_FILE;
    155     else if (RTFS_IS_DIRECTORY(fMode))
    156         fMode |= RTFS_DOS_DIRECTORY;
    157     return fMode;
    158 }
    159 
    160 
    161 /**
    162  * Checks if the file mode is valid or not.
    163  *
    164  * @return  true if valid.
    165  * @return  false if invalid, done bitching.
    166  * @param   fMode       The file mode.
    167  */
    168 bool rtFsModeIsValid(RTFMODE fMode)
    169 {
    170     AssertMsgReturn(   (!RTFS_IS_DIRECTORY(fMode) && !(fMode & RTFS_DOS_DIRECTORY))
    171                     || (RTFS_IS_DIRECTORY(fMode) && (fMode & RTFS_DOS_DIRECTORY)),
    172                     ("%RTfmode\n", fMode), false);
    173     AssertMsgReturn(RTFS_TYPE_MASK & fMode,
    174                     ("%RTfmode\n", fMode), false);
    175     /** @todo more checks! */
    176     return true;
    177 }
    178 
    179 
    180 /**
    181  * Checks if the file mode is valid as a permission mask or not.
    182  *
    183  * @return  true if valid.
    184  * @return  false if invalid, done bitching.
    185  * @param   fMode       The file mode.
    186  */
    187 bool rtFsModeIsValidPermissions(RTFMODE fMode)
    188 {
    189     AssertMsgReturn(   (!RTFS_IS_DIRECTORY(fMode) && !(fMode & RTFS_DOS_DIRECTORY))
    190                     || (RTFS_IS_DIRECTORY(fMode) && (fMode & RTFS_DOS_DIRECTORY)),
    191                     ("%RTfmode\n", fMode), false);
    192     /** @todo more checks! */
    193     return true;
    194 }
    195 
    196 #ifndef RT_OS_WINDOWS
    19746
    19847/**
    … …  
    303152}
    304153
    305 
    306 /**
    307  * Set user-owner additional attributes.
    308  *
    309  * @param   pObjInfo            The object info to fill add attrs for.
    310  * @param   uid                 The user id.
    311  */
    312 void    rtFsObjInfoAttrSetUnixOwner(PRTFSOBJINFO pObjInfo, RTUID uid)
    313 {
    314     pObjInfo->Attr.enmAdditional   = RTFSOBJATTRADD_UNIX_OWNER;
    315     pObjInfo->Attr.u.UnixOwner.uid = uid;
    316     pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
    317 
    318     char            achBuf[_4K];
    319     struct passwd   Pwd;
    320     struct passwd  *pPwd;
    321     int rc = getpwuid_r(uid, &Pwd, achBuf, sizeof(achBuf), &pPwd);
    322     if (!rc && pPwd)
    323         RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName), pPwd->pw_name);
    324 }
    325 
    326 
    327 /**
    328  * Set user-group additional attributes.
    329  *
    330  * @param   pObjInfo            The object info to fill add attrs for.
    331  * @param   gid                 The group id.
    332  */
    333 void rtFsObjInfoAttrSetUnixGroup(PRTFSOBJINFO pObjInfo, RTUID gid)
    334 {
    335     pObjInfo->Attr.enmAdditional   = RTFSOBJATTRADD_UNIX_GROUP;
    336     pObjInfo->Attr.u.UnixGroup.gid = gid;
    337     pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
    338 
    339     char            achBuf[_4K];
    340     struct group    Grp;
    341     struct group   *pGrp;
    342 
    343     int rc = getgrgid_r(gid, &Grp, achBuf, sizeof(achBuf), &pGrp);
    344     if (!rc && pGrp)
    345         RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName), pGrp->gr_name);
    346 }
    347 
    348 #endif /* !RT_OS_WINDOWS */
    349 
    350 
    351 RTDECL(const char *) RTFsTypeName(RTFSTYPE enmType)
    352 {
    353     switch (enmType)
    354     {
    355         case RTFSTYPE_UNKNOWN:      return "unknown";
    356         case RTFSTYPE_UDF:          return "udf";
    357         case RTFSTYPE_ISO9660:      return "iso9660";
    358         case RTFSTYPE_FUSE:         return "fuse";
    359         case RTFSTYPE_VBOXSHF:      return "vboxshf";
    360 
    361         case RTFSTYPE_EXT:          return "ext";
    362         case RTFSTYPE_EXT2:         return "ext2";
    363         case RTFSTYPE_EXT3:         return "ext3";
    364         case RTFSTYPE_EXT4:         return "ext4";
    365         case RTFSTYPE_XFS:          return "xfs";
    366         case RTFSTYPE_CIFS:         return "cifs";
    367         case RTFSTYPE_SMBFS:        return "smbfs";
    368         case RTFSTYPE_TMPFS:        return "tmpfs";
    369         case RTFSTYPE_SYSFS:        return "sysfs";
    370         case RTFSTYPE_PROC:         return "proc";
    371 
    372         case RTFSTYPE_NTFS:         return "ntfs";
    373         case RTFSTYPE_FAT:          return "fat";
    374 
    375         case RTFSTYPE_ZFS:          return "zfs";
    376         case RTFSTYPE_UFS:          return "ufs";
    377         case RTFSTYPE_NFS:          return "nfs";
    378 
    379         case RTFSTYPE_HFS:          return "hfs";
    380         case RTFSTYPE_AUTOFS:       return "autofs";
    381         case RTFSTYPE_DEVFS:        return "devfs";
    382 
    383         case RTFSTYPE_HPFS:         return "hpfs";
    384         case RTFSTYPE_JFS:          return "jfs";
    385 
    386         case RTFSTYPE_END:          return "end";
    387         case RTFSTYPE_32BIT_HACK:   break;
    388     }
    389 
    390     /* Don't put this in as 'default:', we wish GCC to warn about missing cases. */
    391     static char                 s_asz[4][64];
    392     static uint32_t volatile    s_i = 0;
    393     uint32_t i = ASMAtomicIncU32(&s_i) % RT_ELEMENTS(s_asz);
    394     RTStrPrintf(s_asz[i], sizeof(s_asz[i]), "type=%d", enmType);
    395     return s_asz[i];
    396 }
    397 
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette