VirtualBox

Ignore:
Timestamp:
Feb 24, 2023 8:49:40 AM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
156009
Message:

Guest Control: Implemented directory handling / walking as non-toolbox variants. bugref:9783

Location:
trunk/src/VBox/Additions/common/VBoxService
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.h

    r98526 r98709  
    3939#include <VBox/GuestHost/GuestControl.h>
    4040#include <VBox/HostServices/GuestControlSvc.h>
     41
     42#include "VBoxServiceUtils.h" /* For VGSVCIDCACHE. */
    4143
    4244
     
    219221    /** How many processes do we allow keeping around at a time? */
    220222    uint32_t                        uProcsMaxKept;
     223    /** The uid/gid cache for this session. */
     224    VGSVCIDCACHE                    IdCache;
    221225} VBOXSERVICECTRLSESSION;
    222226/** Pointer to guest session. */
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlSession.cpp

    r98665 r98709  
    11371137     */
    11381138    uint32_t           uHandle;
    1139     size_t             cbDirEntry;
     1139    size_t             cbDirEntry = 0;
    11401140    GSTCTLFSOBJATTRADD enmAttrAdd;
    11411141    uint32_t           fFlags;
     
    11471147        if (pDir)
    11481148        {
    1149             VGSvcVerbose(2, "[Dir %s] Reading next entry (handle=%RU32)\n", pDir ? pDir->pszPathAbs : "<Not found>", uHandle);
     1149            RT_ZERO(DirEntryEx);
    11501150
    11511151            /*
     
    11671167            AssertStmt(cbDirEntry <= _256K, rc = VERR_BUFFER_OVERFLOW);
    11681168
    1169             if (RT_SUCCESS(rc))
    1170             {
    1171                 int rc2 = VbglR3GuestCtrlDirCbRead(pHostCtx, rc, &DirEntryEx, (uint32_t)cbDirEntry);
    1172                 if (RT_FAILURE(rc2))
    1173                     VGSvcError("Failed to report directory read status, rc=%Rrc\n", rc2);
    1174             }
     1169            VGSvcVerbose(2, "[Dir %s] Read next entry '%s' -> %Rrc\n",
     1170                         pDir->pszPathAbs, RT_SUCCESS(rc) ? DirEntryEx.szName : "<None>", rc);
     1171
     1172            char *pszUser = RT_SUCCESS(rc)
     1173                          ? RTStrDup(VGSvcIdCacheGetUidName(&pSession->IdCache,
     1174                                                            DirEntryEx.Info.Attr.u.Unix.uid, DirEntryEx.szName, pDir->pszPathAbs))
     1175                          : NULL;
     1176
     1177            char *pszGroup = RT_SUCCESS(rc)
     1178                           ? RTStrDup(VGSvcIdCacheGetGidName(&pSession->IdCache,
     1179                                                             DirEntryEx.Info.Attr.u.Unix.gid, DirEntryEx.szName, pDir->pszPathAbs))
     1180                           : NULL;
     1181
     1182            VGSvcVerbose(2, "[Dir %s] Entry '%s': %zu bytes, uid=%s (%d), gid=%s (%d)\n",
     1183                         pDir->pszPathAbs, DirEntryEx.szName, DirEntryEx.Info.cbObject,
     1184                         pszUser ? pszUser : "", DirEntryEx.Info.Attr.u.UnixOwner.uid,
     1185                         pszGroup ? pszGroup : "", DirEntryEx.Info.Attr.u.UnixGroup.gid);
     1186
     1187            char szIgnored[] = "???"; /** @todo Implement ACL support. */
     1188            int rc2 = VbglR3GuestCtrlDirCbReadEx(pHostCtx, rc,
     1189                                                 &DirEntryEx, (uint32_t)(sizeof(GSTCTLDIRENTRYEX) + cbDirEntry),
     1190                                                 pszUser ? pszUser : szIgnored, pszGroup ? pszGroup : szIgnored,
     1191                                                 szIgnored /* pvACL */, sizeof(szIgnored) /* cbACL */);
     1192            RTStrFree(pszUser);
     1193            RTStrFree(pszGroup);
     1194
     1195            if (RT_FAILURE(rc2))
     1196                VGSvcError("Failed to report directory read status (%Rrc), rc=%Rrc\n", rc, rc2);
     1197
     1198            if (rc == VERR_NO_MORE_FILES) /* Directory reading done. */
     1199                rc = VINF_SUCCESS;
    11751200
    11761201            vgsvcGstCtrlSessionDirRelease(pDir);
     
    11801205            VGSvcError("Directory %u (%#x) not found!\n", uHandle, uHandle);
    11811206            rc = VERR_NOT_FOUND;
    1182         }
    1183 
    1184         if (RT_FAILURE(rc))
    1185         {
    1186             /* On failure we send a simply reply to save bandwidth. */
    1187             int rc2 = VbglR3GuestCtrlMsgReply(pHostCtx, rc);
    1188             if (RT_FAILURE(rc2))
    1189             {
    1190                 VGSvcError("Failed to report directory read error %Rrc, rc=%Rrc\n", rc, rc2);
    1191                 if (RT_SUCCESS(rc))
    1192                     rc = rc2;
    1193             }
    11941207        }
    11951208    }
     
    17821795        uint32_t fFlagsRuntime = 0;
    17831796
    1784         if (!(fFlags & ~GSTCTL_QUERYINFO_F_VALID_MASK))
    1785         {
    1786             if (fFlags & GSTCTL_QUERYINFO_F_ON_LINK)
     1797        if (!(fFlags & ~GSTCTL_PATH_F_VALID_MASK))
     1798        {
     1799            if (fFlags & GSTCTL_PATH_F_ON_LINK)
    17871800                fFlagsRuntime |= RTPATH_F_ON_LINK;
    1788             if (fFlags & GSTCTL_QUERYINFO_F_FOLLOW_LINK)
     1801            if (fFlags & GSTCTL_PATH_F_FOLLOW_LINK)
    17891802                fFlagsRuntime |= RTPATH_F_FOLLOW_LINK;
    1790             if (fFlags & GSTCTL_QUERYINFO_F_NO_SYMLINKS)
     1803            if (fFlags & GSTCTL_PATH_F_NO_SYMLINKS)
    17911804                fFlagsRuntime |= RTPATH_F_NO_SYMLINKS;
    17921805
     
    18361849        PGSTCTLFSOBJINFO pObjInfo = (PGSTCTLFSOBJINFO)&objInfoRuntime;
    18371850
    1838         /** @todo Implement lookups! */
    1839         char  szNotImplemented[] = "<not-implemented>";
    1840         char *pszUser   = szNotImplemented;
    1841         char *pszGroups = szNotImplemented;
    1842         int rc2 = VbglR3GuestCtrlFsCbQueryInfoEx(pHostCtx, rc, pObjInfo, pszUser, pszGroups,
     1851        char *pszUser = RTStrDup(  RT_SUCCESS(rc)
     1852                                 ? VGSvcIdCacheGetUidName(&pSession->IdCache, pObjInfo->Attr.u.Unix.uid, szPath, NULL /* pszRelativeTo */)
     1853                                 : "<error>");
     1854        AssertStmt(pszUser != NULL, rc = VERR_NO_MEMORY);
     1855
     1856        char *pszGroup = RTStrDup(  RT_SUCCESS(rc)
     1857                                  ? VGSvcIdCacheGetGidName(&pSession->IdCache, pObjInfo->Attr.u.Unix.gid, szPath, NULL /* pszRelativeTo */)
     1858                                  : "<error>");
     1859        AssertStmt(pszGroup != NULL, rc = VERR_NO_MEMORY);
     1860
     1861        char  szNotImplemented[] = "<not-implemented>"; /** @todo Implement ACL support. */
     1862        int rc2 = VbglR3GuestCtrlFsCbQueryInfoEx(pHostCtx, rc, pObjInfo, pszUser, pszGroup,
    18431863                                                 szNotImplemented, sizeof(szNotImplemented));
     1864        RTStrFree(pszUser);
     1865        RTStrFree(pszGroup);
     1866
    18441867        if (RT_FAILURE(rc2))
    18451868        {
     
    26792702
    26802703    pSession->fFlags = fFlags;
     2704
     2705    RT_ZERO(pSession->IdCache);
    26812706
    26822707    /* Init critical section for protecting the thread lists. */
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceToolBox.cpp

    r98103 r98709  
    132132    char       *pszName;
    133133} VBOXSERVICETOOLBOXPATHENTRY, *PVBOXSERVICETOOLBOXPATHENTRY;
    134 
    135 /** ID cache entry. */
    136 typedef struct VGSVCTOOLBOXUIDENTRY
    137 {
    138     /** The identifier name. */
    139     uint32_t    id;
    140     /** Set if UID, clear if GID. */
    141     bool        fIsUid;
    142     /** The name. */
    143     char        szName[128 - 4 - 1];
    144 } VGSVCTOOLBOXUIDENTRY;
    145 typedef VGSVCTOOLBOXUIDENTRY *PVGSVCTOOLBOXUIDENTRY;
    146 
    147 
    148 /** ID cache. */
    149 typedef struct VGSVCTOOLBOXIDCACHE
    150 {
    151     /** Number of valid cache entries. */
    152     uint32_t                cEntries;
    153     /** The next entry to replace. */
    154     uint32_t                iNextReplace;
    155     /** The cache entries. */
    156     VGSVCTOOLBOXUIDENTRY    aEntries[16];
    157 } VGSVCTOOLBOXIDCACHE;
    158 typedef VGSVCTOOLBOXIDCACHE *PVGSVCTOOLBOXIDCACHE;
    159134
    160135
     
    575550
    576551/**
    577  * Resolves the UID to a name as best as we can.
    578  *
    579  * @returns Read-only name string.  Only valid till the next cache call.
    580  * @param   pIdCache        The ID cache.
    581  * @param   uid             The UID to resolve.
    582  * @param   pszEntry        The filename of the UID.
    583  * @param   pszRelativeTo   What @a pszEntry is relative to, NULL if absolute.
    584  */
    585 static const char *vgsvcToolboxIdCacheGetUidName(PVGSVCTOOLBOXIDCACHE pIdCache, RTUID uid,
    586                                                  const char *pszEntry, const char *pszRelativeTo)
    587 {
    588     /* Check cached entries. */
    589     for (uint32_t i = 0; i < pIdCache->cEntries; i++)
    590         if (   pIdCache->aEntries[i].id == uid
    591             && pIdCache->aEntries[i].fIsUid)
    592             return pIdCache->aEntries[i].szName;
    593 
    594     /* Miss. */
    595     RTFSOBJINFO ObjInfo;
    596     RT_ZERO(ObjInfo); /* shut up msc */
    597     int rc;
    598     if (!pszRelativeTo)
    599         rc = RTPathQueryInfoEx(pszEntry, &ObjInfo, RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK);
    600     else
    601     {
    602         char szPath[RTPATH_MAX];
    603         rc = RTPathJoin(szPath, sizeof(szPath), pszRelativeTo, pszEntry);
    604         if (RT_SUCCESS(rc))
    605             rc = RTPathQueryInfoEx(szPath, &ObjInfo, RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK);
    606     }
    607 
    608     if (   RT_SUCCESS(rc)
    609         && ObjInfo.Attr.u.UnixOwner.uid == uid)
    610     {
    611         uint32_t i = pIdCache->cEntries;
    612         if (i < RT_ELEMENTS(pIdCache->aEntries))
    613             pIdCache->cEntries = i + 1;
    614         else
    615             i = pIdCache->iNextReplace++ % RT_ELEMENTS(pIdCache->aEntries);
    616         pIdCache->aEntries[i].id     = uid;
    617         pIdCache->aEntries[i].fIsUid = true;
    618         RTStrCopy(pIdCache->aEntries[i].szName, sizeof(pIdCache->aEntries[i].szName), ObjInfo.Attr.u.UnixOwner.szName);
    619         return pIdCache->aEntries[i].szName;
    620     }
    621     return "";
    622 }
    623 
    624 
    625 /**
    626  * Resolves the GID to a name as best as we can.
    627  *
    628  * @returns Read-only name string.  Only valid till the next cache call.
    629  * @param   pIdCache        The ID cache.
    630  * @param   gid             The GID to resolve.
    631  * @param   pszEntry        The filename of the GID.
    632  * @param   pszRelativeTo   What @a pszEntry is relative to, NULL if absolute.
    633  */
    634 static const char *vgsvcToolboxIdCacheGetGidName(PVGSVCTOOLBOXIDCACHE pIdCache, RTGID gid,
    635                                                  const char *pszEntry, const char *pszRelativeTo)
    636 {
    637     /* Check cached entries. */
    638     for (uint32_t i = 0; i < pIdCache->cEntries; i++)
    639         if (   pIdCache->aEntries[i].id == gid
    640             && !pIdCache->aEntries[i].fIsUid)
    641             return pIdCache->aEntries[i].szName;
    642 
    643     /* Miss. */
    644     RTFSOBJINFO ObjInfo;
    645     RT_ZERO(ObjInfo); /* shut up msc */
    646     int rc;
    647     if (!pszRelativeTo)
    648         rc = RTPathQueryInfoEx(pszEntry, &ObjInfo, RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK);
    649     else
    650     {
    651         char szPath[RTPATH_MAX];
    652         rc = RTPathJoin(szPath, sizeof(szPath), pszRelativeTo, pszEntry);
    653         if (RT_SUCCESS(rc))
    654             rc = RTPathQueryInfoEx(szPath, &ObjInfo, RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK);
    655     }
    656 
    657     if (   RT_SUCCESS(rc)
    658         && ObjInfo.Attr.u.UnixGroup.gid == gid)
    659     {
    660         uint32_t i = pIdCache->cEntries;
    661         if (i < RT_ELEMENTS(pIdCache->aEntries))
    662             pIdCache->cEntries = i + 1;
    663         else
    664             i = pIdCache->iNextReplace++ % RT_ELEMENTS(pIdCache->aEntries);
    665         pIdCache->aEntries[i].id     = gid;
    666         pIdCache->aEntries[i].fIsUid = false;
    667         RTStrCopy(pIdCache->aEntries[i].szName, sizeof(pIdCache->aEntries[i].szName), ObjInfo.Attr.u.UnixGroup.szName);
    668         return pIdCache->aEntries[i].szName;
    669     }
    670     return "";
    671 }
    672 
    673 
    674 /**
    675552 * Prints information (based on given flags) of a file system object (file/directory/...)
    676553 * to stdout.
     
    686563 */
    687564static int vgsvcToolboxPrintFsInfo(const char *pszName, size_t cchName, uint32_t fOutputFlags, const char *pszRelativeTo,
    688                                    PVGSVCTOOLBOXIDCACHE pIdCache, PRTFSOBJINFO pObjInfo)
     565                                   PVGSVCIDCACHE pIdCache, PRTFSOBJINFO pObjInfo)
    689566{
    690567    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
     
    773650            if (pObjInfo->Attr.u.Unix.uid != NIL_RTUID)
    774651                RTPrintf("uid=%RU32%cusername=%s%c", pObjInfo->Attr.u.Unix.uid, 0,
    775                          vgsvcToolboxIdCacheGetUidName(pIdCache, pObjInfo->Attr.u.Unix.uid, pszName, pszRelativeTo), 0);
     652                         VGSvcIdCacheGetUidName(pIdCache, pObjInfo->Attr.u.Unix.uid, pszName, pszRelativeTo), 0);
    776653            if (pObjInfo->Attr.u.Unix.gid != NIL_RTGID)
    777654                RTPrintf("gid=%RU32%cgroupname=%s%c", pObjInfo->Attr.u.Unix.gid, 0,
    778                          vgsvcToolboxIdCacheGetGidName(pIdCache, pObjInfo->Attr.u.Unix.gid, pszName, pszRelativeTo), 0);
     655                         VGSvcIdCacheGetGidName(pIdCache, pObjInfo->Attr.u.Unix.gid, pszName, pszRelativeTo), 0);
    779656            if (   (RTFS_IS_DEV_BLOCK(pObjInfo->Attr.fMode) || RTFS_IS_DEV_CHAR(pObjInfo->Attr.fMode))
    780657                && pObjInfo->Attr.u.Unix.Device)
     
    847724 */
    848725static int vgsvcToolboxLsHandleDirSub(char *pszDir, size_t cchDir, PRTDIRENTRYEX pDirEntry,
    849                                       uint32_t fFlags, uint32_t fOutputFlags, PVGSVCTOOLBOXIDCACHE pIdCache)
     726                                      uint32_t fFlags, uint32_t fOutputFlags, PVGSVCIDCACHE pIdCache)
    850727{
    851728    Assert(cchDir > 0); Assert(pszDir[cchDir] == '\0');
     
    971848 * @param   pIdCache        The ID cache.
    972849 */
    973 static int vgsvcToolboxLsHandleDir(const char *pszDir, uint32_t fFlags, uint32_t fOutputFlags, PVGSVCTOOLBOXIDCACHE pIdCache)
     850static int vgsvcToolboxLsHandleDir(const char *pszDir, uint32_t fFlags, uint32_t fOutputFlags, PVGSVCIDCACHE pIdCache)
    974851{
    975852    AssertPtrReturn(pszDir, VERR_INVALID_PARAMETER);
     
    1094971    }
    1095972
    1096     VGSVCTOOLBOXIDCACHE IdCache;
     973    VGSVCIDCACHE IdCache;
    1097974    RT_ZERO(IdCache);
    1098975
     
    15931470        }
    15941471
    1595         VGSVCTOOLBOXIDCACHE IdCache;
     1472        VGSVCIDCACHE IdCache;
    15961473        RT_ZERO(IdCache);
    15971474
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceUtils.cpp

    r98103 r98709  
    4141#include <VBox/VBoxGuestLib.h>
    4242#include "VBoxServiceInternal.h"
     43#include "VBoxServiceUtils.h"
    4344
    4445
     
    323324#endif /* RT_OS_WINDOWS */
    324325
     326
     327/**
     328 * Resolves the UID to a name as best as we can.
     329 *
     330 * @returns Read-only name string.  Only valid till the next cache call.
     331 * @param   pIdCache        The ID cache.
     332 * @param   uid             The UID to resolve.
     333 * @param   pszEntry        The filename of the UID.
     334 * @param   pszRelativeTo   What @a pszEntry is relative to, NULL if absolute.
     335 */
     336const char *VGSvcIdCacheGetUidName(PVGSVCIDCACHE pIdCache, RTUID uid, const char *pszEntry, const char *pszRelativeTo)
     337{
     338    /* Check cached entries. */
     339    for (uint32_t i = 0; i < pIdCache->cEntries; i++)
     340        if (   pIdCache->aEntries[i].id == uid
     341            && pIdCache->aEntries[i].fIsUid)
     342            return pIdCache->aEntries[i].szName;
     343
     344    /* Miss. */
     345    RTFSOBJINFO ObjInfo;
     346    RT_ZERO(ObjInfo); /* shut up msc */
     347    int rc;
     348    if (!pszRelativeTo)
     349        rc = RTPathQueryInfoEx(pszEntry, &ObjInfo, RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK);
     350    else
     351    {
     352        char szPath[RTPATH_MAX];
     353        rc = RTPathJoin(szPath, sizeof(szPath), pszRelativeTo, pszEntry);
     354        if (RT_SUCCESS(rc))
     355            rc = RTPathQueryInfoEx(szPath, &ObjInfo, RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK);
     356    }
     357
     358    if (   RT_SUCCESS(rc)
     359        && ObjInfo.Attr.u.UnixOwner.uid == uid)
     360    {
     361        uint32_t i = pIdCache->cEntries;
     362        if (i < RT_ELEMENTS(pIdCache->aEntries))
     363            pIdCache->cEntries = i + 1;
     364        else
     365            i = pIdCache->iNextReplace++ % RT_ELEMENTS(pIdCache->aEntries);
     366        pIdCache->aEntries[i].id     = uid;
     367        pIdCache->aEntries[i].fIsUid = true;
     368        RTStrCopy(pIdCache->aEntries[i].szName, sizeof(pIdCache->aEntries[i].szName), ObjInfo.Attr.u.UnixOwner.szName);
     369        return pIdCache->aEntries[i].szName;
     370    }
     371    return "";
     372}
     373
     374
     375/**
     376 * Resolves the GID to a name as best as we can.
     377 *
     378 * @returns Read-only name string.  Only valid till the next cache call.
     379 * @param   pIdCache        The ID cache.
     380 * @param   gid             The GID to resolve.
     381 * @param   pszEntry        The filename of the GID.
     382 * @param   pszRelativeTo   What @a pszEntry is relative to, NULL if absolute.
     383 */
     384const char *VGSvcIdCacheGetGidName(PVGSVCIDCACHE pIdCache, RTGID gid, const char *pszEntry, const char *pszRelativeTo)
     385{
     386    /* Check cached entries. */
     387    for (uint32_t i = 0; i < pIdCache->cEntries; i++)
     388        if (   pIdCache->aEntries[i].id == gid
     389            && !pIdCache->aEntries[i].fIsUid)
     390            return pIdCache->aEntries[i].szName;
     391
     392    /* Miss. */
     393    RTFSOBJINFO ObjInfo;
     394    RT_ZERO(ObjInfo); /* shut up msc */
     395    int rc;
     396    if (!pszRelativeTo)
     397        rc = RTPathQueryInfoEx(pszEntry, &ObjInfo, RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK);
     398    else
     399    {
     400        char szPath[RTPATH_MAX];
     401        rc = RTPathJoin(szPath, sizeof(szPath), pszRelativeTo, pszEntry);
     402        if (RT_SUCCESS(rc))
     403            rc = RTPathQueryInfoEx(szPath, &ObjInfo, RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK);
     404    }
     405
     406    if (   RT_SUCCESS(rc)
     407        && ObjInfo.Attr.u.UnixGroup.gid == gid)
     408    {
     409        uint32_t i = pIdCache->cEntries;
     410        if (i < RT_ELEMENTS(pIdCache->aEntries))
     411            pIdCache->cEntries = i + 1;
     412        else
     413            i = pIdCache->iNextReplace++ % RT_ELEMENTS(pIdCache->aEntries);
     414        pIdCache->aEntries[i].id     = gid;
     415        pIdCache->aEntries[i].fIsUid = false;
     416        RTStrCopy(pIdCache->aEntries[i].szName, sizeof(pIdCache->aEntries[i].szName), ObjInfo.Attr.u.UnixGroup.szName);
     417        return pIdCache->aEntries[i].szName;
     418    }
     419    return "";
     420}
     421
  • trunk/src/VBox/Additions/common/VBoxService/VBoxServiceUtils.h

    r98103 r98709  
    3434#include "VBoxServiceInternal.h"
    3535
     36/** ID cache entry. */
     37typedef struct VGSVCUIDENTRY
     38{
     39    /** The identifier name. */
     40    uint32_t    id;
     41    /** Set if UID, clear if GID. */
     42    bool        fIsUid;
     43    /** The name. */
     44    char        szName[128 - 4 - 1];
     45} VGSVCUIDENTRY;
     46typedef VGSVCUIDENTRY *PVGSVCUIDENTRY;
     47
     48
     49/** ID cache. */
     50typedef struct VGSVCIDCACHE
     51{
     52    /** Number of valid cache entries. */
     53    uint32_t                cEntries;
     54    /** The next entry to replace. */
     55    uint32_t                iNextReplace;
     56    /** The cache entries. */
     57    VGSVCUIDENTRY           aEntries[16];
     58} VGSVCIDCACHE;
     59typedef VGSVCIDCACHE *PVGSVCIDCACHE;
     60
    3661#ifdef VBOX_WITH_GUEST_PROPS
    3762int VGSvcReadProp(uint32_t u32ClientId, const char *pszPropName, char **ppszValue, char **ppszFlags, uint64_t *puTimestamp);
     
    4671#endif
    4772
     73const char *VGSvcIdCacheGetUidName(PVGSVCIDCACHE pIdCache, RTUID uid, const char *pszEntry, const char *pszRelativeTo);
     74const char *VGSvcIdCacheGetGidName(PVGSVCIDCACHE pIdCache, RTGID gid, const char *pszEntry, const char *pszRelativeTo);
     75
    4876#endif /* !GA_INCLUDED_SRC_common_VBoxService_VBoxServiceUtils_h */
    4977
Note: See TracChangeset for help on using the changeset viewer.

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