VirtualBox

Ignore:
Timestamp:
Feb 10, 2023 3:10:50 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
155802
Message:

Guest Control: Initial commit (work in progress, disabled by default). bugref:9783

IGuestDirectory:

Added new attributes id + status + an own event source. Also added for rewind support via rewind().

New event types for guest directory [un]registration, state changes and entry reads.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestCtrl.cpp

    r98103 r98526  
    980980
    981981
     982#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
     983/**
     984 * Retrieves a HOST_MSG_DIR_OPEN message.
     985 *
     986 * @returns VBox status code.
     987 * @param   pCtx                Guest control command context to use.
     988 * @param   pszPath             Where to return the directory path to open.
     989 * @param   cbPath              Size (in bytes) of \a pszPath.
     990 * @param   pfFlags             Where to return the directory listing flags.
     991 * @param   enmFilter           Where to return the directory filter type.
     992 */
     993VBGLR3DECL(int) VbglR3GuestCtrlDirGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszPath, uint32_t cbPath, uint32_t *pfFlags,
     994                                          GSTCTLDIRFILTER *penmFilter)
     995{
     996    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     997    AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     998
     999    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     1000    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
     1001    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     1002    AssertPtrReturn(penmFilter, VERR_INVALID_POINTER);
     1003
     1004    int rc;
     1005    do
     1006    {
     1007        HGCMMsgDirOpen Msg;
     1008        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1009        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_OPEN);
     1010        VbglHGCMParmPtrSet(&Msg.path, pszPath, cbPath);
     1011        VbglHGCMParmUInt64Set(&Msg.flags, 0);
     1012        VbglHGCMParmUInt64Set(&Msg.filter, 0);
     1013
     1014        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1015        if (RT_SUCCESS(rc))
     1016        {
     1017            Msg.context.GetUInt32(&pCtx->uContextID);
     1018            Msg.flags.GetUInt32(pfFlags);
     1019            Msg.filter.GetUInt32((uint32_t *)penmFilter);
     1020        }
     1021    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1022    return rc;
     1023}
     1024
     1025
     1026/**
     1027 * Retrieves a HOST_MSG_DIR_CLOSE message.
     1028 *
     1029 * @returns VBox status code.
     1030 * @param   pCtx                Guest control command context to use.
     1031 * @param   puHandle            Where to return the handle of the guest directory to close.
     1032 */
     1033VBGLR3DECL(int) VbglR3GuestCtrlDirGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle)
     1034{
     1035    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     1036    AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     1037
     1038    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     1039
     1040    int rc;
     1041    do
     1042    {
     1043        HGCMMsgDirClose Msg;
     1044        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1045        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_CLOSE);
     1046        VbglHGCMParmUInt64Set(&Msg.handle, 0);
     1047
     1048        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1049        if (RT_SUCCESS(rc))
     1050        {
     1051            Msg.context.GetUInt32(&pCtx->uContextID);
     1052            Msg.handle.GetUInt32(puHandle);
     1053        }
     1054    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1055    return rc;
     1056}
     1057
     1058
     1059/**
     1060 * Retrieves a HOST_MSG_DIR_READ message.
     1061 *
     1062 * @returns VBox status code.
     1063 * @param   pCtx                Guest control command context to use.
     1064 * @param   puHandle            Where to return the directory handle to rewind.
     1065 * @param   pcbDirEntry         Where to return the directory entry size.
     1066 * @param   penmAddAttrib       Where to return the additional attributes enumeration.
     1067 * @param   pfFlags             Where to return the directory reading flags..
     1068 */
     1069VBGLR3DECL(int) VbglR3GuestCtrlDirGetRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle, uint32_t *pcbDirEntry,
     1070                                          uint32_t *penmAddAttrib, uint32_t *pfFlags)
     1071{
     1072    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     1073    AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     1074
     1075    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     1076    AssertPtrReturn(pcbDirEntry, VERR_INVALID_POINTER);
     1077    AssertPtrReturn(penmAddAttrib, VERR_INVALID_POINTER);
     1078    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     1079
     1080    int rc;
     1081    do
     1082    {
     1083        HGCMMsgDirRead Msg;
     1084        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1085        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_READ);
     1086        VbglHGCMParmUInt64Set(&Msg.handle, 0);
     1087        VbglHGCMParmUInt32Set(&Msg.entry_size, 0);
     1088        VbglHGCMParmUInt32Set(&Msg.add_attributes, 0);
     1089        VbglHGCMParmUInt32Set(&Msg.flags, 0);
     1090
     1091        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1092        if (RT_SUCCESS(rc))
     1093        {
     1094            Msg.context.GetUInt32(&pCtx->uContextID);
     1095            Msg.handle.GetUInt32(puHandle);
     1096            Msg.entry_size.GetUInt32(pcbDirEntry);
     1097            Msg.add_attributes.GetUInt32(penmAddAttrib);
     1098            Msg.flags.GetUInt32(pfFlags);
     1099        }
     1100    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1101    return rc;
     1102}
     1103
     1104
     1105/**
     1106 * Retrieves a HOST_MSG_DIR_REWIND message.
     1107 *
     1108 * @returns VBox status code.
     1109 * @param   pCtx                Guest control command context to use.
     1110 * @param   puHandle            Where to return the directory handle to rewind.
     1111 */
     1112VBGLR3DECL(int) VbglR3GuestCtrlDirGetRewind(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle)
     1113{
     1114    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     1115    AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     1116
     1117    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     1118
     1119    int rc;
     1120    do
     1121    {
     1122        HGCMMsgDirRewind Msg;
     1123        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1124        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_REWIND);
     1125        VbglHGCMParmUInt64Set(&Msg.handle, 0);
     1126
     1127        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1128        if (RT_SUCCESS(rc))
     1129        {
     1130            Msg.context.GetUInt32(&pCtx->uContextID);
     1131            Msg.handle.GetUInt32(puHandle);
     1132        }
     1133    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1134    return rc;
     1135}
     1136#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     1137
     1138
    9821139/**
    9831140 * Retrieves a HOST_PATH_RENAME message.
    … …  
    10631220    return rc;
    10641221}
     1222
     1223
     1224#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
     1225/**
     1226 * Retrieves a HOST_MSG_FS_QUERY_INFO message.
     1227 *
     1228 * @returns VBox status code.
     1229 * @param   pCtx                Guest control command context to use.
     1230 * @param   pszPath             Where to return the path of the file system object to query.
     1231 * @param   cbPath              Size (in bytes) of \a pszPath.
     1232 * @param   penmAddAttrib       Where to return the additional attributes enumeration.
     1233 * @param   pfFlags             Where to return the flags for .
     1234 */
     1235VBGLR3DECL(int) VbglR3GuestCtrlFsGetQueryInfo(PVBGLR3GUESTCTRLCMDCTX pCtx,
     1236                                              char *pszPath, uint32_t cbPath, GSTCTLFSOBJATTRADD *penmAddAttrib, uint32_t *pfFlags)
     1237{
     1238    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     1239    AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     1240
     1241    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     1242    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
     1243    AssertPtrReturn(penmAddAttrib, VERR_INVALID_POINTER);
     1244    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     1245
     1246    int rc;
     1247    do
     1248    {
     1249        HGCMMsgFsQueryInfo Msg;
     1250        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1251        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FS_QUERY_INFO);
     1252        VbglHGCMParmPtrSet(&Msg.path, pszPath, cbPath);
     1253        VbglHGCMParmUInt32Set(&Msg.add_attributes, 0);
     1254        VbglHGCMParmUInt32Set(&Msg.flags, 0);
     1255
     1256        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1257        if (RT_SUCCESS(rc))
     1258        {
     1259            Msg.context.GetUInt32(&pCtx->uContextID);
     1260            Msg.add_attributes.GetUInt32((uint32_t *)penmAddAttrib);
     1261            Msg.flags.GetUInt32(pfFlags);
     1262        }
     1263
     1264    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1265    return rc;
     1266}
     1267
     1268
     1269/**
     1270 * Retrieves a HOST_MSG_FS_CREATE_TEMP message.
     1271 *
     1272 * @returns VBox status code.
     1273 * @param   pCtx                Guest control command context to use.
     1274 * @param   pszTemplate         Where to return the template name.
     1275 * @param   cbTemplate          Size (in bytes) of \a pszTemplate.
     1276 * @param   pszPath             Where to return the temporary directory path.
     1277 * @param   cbTemplate          Size (in bytes) of \a pszPath.
     1278 * @param   pfFlags             Where to return the creation flags.
     1279 * @param   pfMode              Where to return the creation mode.
     1280 */
     1281VBGLR3DECL(int) VbglR3GuestCtrlFsGetCreateTemp(PVBGLR3GUESTCTRLCMDCTX pCtx,
     1282                                               char *pszTemplate, uint32_t cbTemplate, char *pszPath, uint32_t cbPath,
     1283                                               uint32_t *pfFlags, uint32_t *pfMode)
     1284{
     1285    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     1286    AssertReturn(pCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
     1287
     1288    AssertPtrReturn(pszTemplate, VERR_INVALID_POINTER);
     1289    AssertReturn(cbTemplate, VERR_INVALID_PARAMETER);
     1290    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     1291    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
     1292    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     1293    AssertPtrReturn(pfMode, VERR_INVALID_POINTER);
     1294
     1295    int rc;
     1296    do
     1297    {
     1298        HGCMMsgFsCreateTemp Msg;
     1299        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1300        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FS_CREATE_TEMP);
     1301        VbglHGCMParmPtrSet(&Msg.template_name, pszTemplate, cbTemplate);
     1302        VbglHGCMParmPtrSet(&Msg.tmpdir, pszPath, cbPath);
     1303        VbglHGCMParmUInt32Set(&Msg.flags, 0);
     1304        VbglHGCMParmUInt32Set(&Msg.mode, 0);
     1305
     1306        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1307        if (RT_SUCCESS(rc))
     1308        {
     1309            Msg.context.GetUInt32(&pCtx->uContextID);
     1310            Msg.flags.GetUInt32(pfFlags);
     1311            Msg.mode.GetUInt32(pfMode);
     1312        }
     1313
     1314    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1315    return rc;
     1316}
     1317#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     1318
    10651319
    10661320/**
    … …  
    14691723
    14701724
     1725#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
     1726/**
     1727 * Retrieves a HOST_MSG_DIR_CREATE message.
     1728 *
     1729 * @returns VBox status code.
     1730 * @param   pCtx                Guest control command context to use.
     1731 * @param   pszPath             Where to return the path.
     1732 * @param   cbPath              Size (in bytes) of \a pszPath.
     1733 * @param   pfMode              Where to return the creation mode.
     1734 * @param   pfFlags             Where to return the creation flags (GSTCTL_CREATEDIRECTORY_F_XXX).
     1735 */
     1736VBGLR3DECL(int) VbglR3GuestCtrlDirGetCreate(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszPath, uint32_t cbPath, uint32_t *pfMode, uint32_t *pfFlags)
     1737{
     1738    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     1739    AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     1740
     1741    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     1742    AssertReturn(cbPath, VERR_INVALID_PARAMETER);
     1743    AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
     1744    AssertPtrReturn(pfMode, VERR_INVALID_POINTER);
     1745
     1746    int rc;
     1747    do
     1748    {
     1749        HGCMMsgDirCreate Msg;
     1750        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     1751        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_DIR_CREATE);
     1752        VbglHGCMParmPtrSet(&Msg.path, pszPath, cbPath);
     1753        VbglHGCMParmUInt32Set(&Msg.mode, 0);
     1754        VbglHGCMParmUInt32Set(&Msg.flags, 0);
     1755
     1756        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     1757        if (RT_SUCCESS(rc))
     1758        {
     1759            Msg.context.GetUInt32(&pCtx->uContextID);
     1760            Msg.flags.GetUInt32(pfFlags);
     1761            Msg.mode.GetUInt32(pfMode);
     1762        }
     1763
     1764    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     1765    return rc;
     1766}
     1767#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     1768
     1769
    14711770/**
    14721771 * Retrieves a HOST_DIR_REMOVE message.
    … …  
    18282127
    18292128
     2129#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
     2130VBGLR3DECL(int) VbglR3GuestCtrlFileGetRemove(PVBGLR3GUESTCTRLCMDCTX pCtx, char *pszFileName, uint32_t cbFileName)
     2131{
     2132    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2133
     2134    AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     2135    AssertPtrReturn(pszFileName, VERR_INVALID_POINTER);
     2136    AssertReturn(cbFileName, VERR_INVALID_PARAMETER);
     2137
     2138    int rc;
     2139    do
     2140    {
     2141        HGCMMsgFileRemove Msg;
     2142        VBGL_HGCM_HDR_INIT(&Msg.hdr, pCtx->uClientID, vbglR3GuestCtrlGetMsgFunctionNo(pCtx->uClientID), pCtx->uNumParms);
     2143        VbglHGCMParmUInt32Set(&Msg.context, HOST_MSG_FILE_REMOVE);
     2144        VbglHGCMParmPtrSet(&Msg.filename, pszFileName, cbFileName);
     2145
     2146        rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg));
     2147        if (RT_SUCCESS(rc))
     2148        {
     2149            Msg.context.GetUInt32(&pCtx->uContextID);
     2150        }
     2151    } while (rc == VERR_INTERRUPTED && g_fVbglR3GuestCtrlHavePeekGetCancel);
     2152    return rc;
     2153}
     2154#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     2155
     2156
    18302157/**
    18312158 * Retrieves a HOST_EXEC_TERMINATE message.
    … …  
    18902217}
    18912218
     2219
     2220/*********************************************************************************************************************************
     2221 * Directory callbacks                                                                                                           *
     2222 ********************************************************************************************************************************/
     2223
     2224#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
     2225/**
     2226 * Replies to a HOST_MSG_DIR_OPEN message.
     2227 *
     2228 * @returns VBox status code.
     2229 * @param   pCtx                Guest control command context to use.
     2230 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2231 * @param   uDirHandle          Directory handle of opened directory.
     2232 */
     2233VBGLR3DECL(int) VbglR3GuestCtrlDirCbOpen(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, uint32_t uDirHandle)
     2234{
     2235    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2236
     2237    HGCMReplyDirNotify Msg;
     2238    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_DIR_NOTIFY,
     2239                       RT_SUCCESS((int)uRc) ? GSTCTL_HGCM_REPLY_HDR_PARMS + 1 : GSTCTL_HGCM_REPLY_HDR_PARMS);
     2240    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
     2241    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_DIR_NOTIFYTYPE_OPEN);
     2242    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
     2243
     2244    if (RT_SUCCESS((int)uRc))
     2245        VbglHGCMParmUInt32Set(&Msg.u.open.handle, uDirHandle);
     2246
     2247    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u.open));
     2248}
     2249
     2250
     2251/**
     2252 * Replies to a HOST_MSG_DIR_CLOSE message.
     2253 *
     2254 * @returns VBox status code.
     2255 * @param   pCtx                Guest control command context to use.
     2256 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2257 */
     2258VBGLR3DECL(int) VbglR3GuestCtrlDirCbClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc)
     2259{
     2260    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2261
     2262    HGCMReplyDirNotify Msg;
     2263    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_DIR_NOTIFY, GSTCTL_HGCM_REPLY_HDR_PARMS);
     2264    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
     2265    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_DIR_NOTIFYTYPE_CLOSE);
     2266    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
     2267
     2268    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u));
     2269}
     2270
     2271
     2272/**
     2273 * Replies to a HOST_MSG_DIR_READ message, extended version.
     2274 *
     2275 * @returns VBox status code.
     2276 * @param   pCtx                Guest control command context to use.
     2277 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2278 * @param   pEntry              Directory entry to send.
     2279 * @param   cbSize              Size (in bytes) of \a pDirEntry to send.
     2280 *                              This might be needed as the size can be bigger than GSTCTLDIRENTRYEX.
     2281 *                              See RTDirReadEx() for more information.
     2282 * @param   pszUser             Associated user ID (owner, uid) as a string.
     2283 * @param   pszGroups           Associated user groups as a string.
     2284 *                              Multiple groups are delimited by "\r\n", whereas the first group always is the primary group.
     2285 * @param   pvACL               ACL block to send.
     2286 * @param   cbACL               Size (in bytes) of ACL block to send.
     2287 */
     2288VBGLR3DECL(int) VbglR3GuestCtrlDirCbReadEx(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, PGSTCTLDIRENTRYEX pEntry, uint32_t cbSize,
     2289                                           char *pszUser, char *pszGroups, void *pvACL, size_t cbACL)
     2290{
     2291    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2292    AssertReturn(RT_FAILURE((int)uRc) || pszUser, VERR_INVALID_POINTER);
     2293    AssertReturn(RT_FAILURE((int)uRc) || pszGroups, VERR_INVALID_POINTER);
     2294    AssertReturn(RT_FAILURE((int)uRc) || pvACL, VERR_INVALID_POINTER);
     2295    AssertReturn(RT_FAILURE((int)uRc) || cbACL, VERR_INVALID_PARAMETER);
     2296
     2297    HGCMReplyDirNotify Msg;
     2298    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_DIR_NOTIFY,
     2299                       RT_SUCCESS((int)uRc) ? GSTCTL_HGCM_REPLY_HDR_PARMS + 4 : GSTCTL_HGCM_REPLY_HDR_PARMS);
     2300    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
     2301    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_DIR_NOTIFYTYPE_READ);
     2302    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
     2303
     2304    if (RT_SUCCESS((int)uRc))
     2305    {
     2306        VbglHGCMParmPtrSet(&Msg.u.read.entry, pEntry, cbSize);
     2307        VbglHGCMParmPtrSetString(&Msg.u.read.user,   pszUser);
     2308        VbglHGCMParmPtrSetString(&Msg.u.read.groups, pszGroups);
     2309        VbglHGCMParmPtrSet      (&Msg.u.read.acl,    pvACL, cbACL);
     2310    }
     2311
     2312    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u.read));
     2313}
     2314
     2315
     2316/**
     2317 * Replies to a HOST_MSG_DIR_READ message.
     2318 *
     2319 * @returns VBox status code.
     2320 * @param   pCtx                Guest control command context to use.
     2321 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2322 * @param   pEntry              Directory entry to send.
     2323 * @param   cbSize              Size (in bytes) of \a pDirEntry to send.
     2324 *                              This might be needed as the size can be bigger than GSTCTLDIRENTRYEX.
     2325 *                              See RTDirReadEx() for more information.
     2326 */
     2327VBGLR3DECL(int) VbglR3GuestCtrlDirCbRead(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, PGSTCTLDIRENTRYEX pEntry, uint32_t cbSize)
     2328{
     2329    char szIgnored[1];
     2330    return VbglR3GuestCtrlDirCbReadEx(pCtx, uRc, pEntry, cbSize, szIgnored /* pszUser */, szIgnored /* pszGroups */,
     2331                                      szIgnored /* pvACL */, sizeof(szIgnored) /* cbACL */);
     2332}
     2333
     2334
     2335/**
     2336 * Replies to a HOST_MSG_DIR_REWIND message.
     2337 *
     2338 * @returns VBox status code.
     2339 * @param   pCtx                Guest control command context to use.
     2340 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2341 */
     2342VBGLR3DECL(int) VbglR3GuestCtrlDirCbRewind(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc)
     2343{
     2344    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2345
     2346    HGCMReplyDirNotify Msg;
     2347    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_DIR_NOTIFY, GSTCTL_HGCM_REPLY_HDR_PARMS);
     2348    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
     2349    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_DIR_NOTIFYTYPE_REWIND);
     2350    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
     2351
     2352    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u));
     2353}
     2354#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     2355
     2356
     2357/*********************************************************************************************************************************
     2358 * File callbacks                                                                                                                *
     2359 ********************************************************************************************************************************/
    18922360
    18932361/**
    … …  
    21282596
    21292597
     2598/*********************************************************************************************************************************
     2599 * File system callbacks                                                                                                         *
     2600 ********************************************************************************************************************************/
     2601
     2602#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
     2603/**
     2604 * Replies to a HOST_MSG_FS_QUERY_INFO message, extended version.
     2605 *
     2606 * @returns VBox status code.
     2607 * @param   pCtx                Guest control command context to use.
     2608 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2609 * @param   pFsObjInfo          Guest file system object information to send.
     2610 * @param   pszUser             Associated user ID (owner, uid) as a string.
     2611 * @param   pszGroups           Associated user groups as a string.
     2612 *                              Multiple groups are delimited by "\r\n", whereas the first group always is the primary group.
     2613 * @param   pvACL               ACL block to send.
     2614 * @param   cbACL               Size (in bytes) of ACL block to send.
     2615 */
     2616VBGLR3DECL(int) VbglR3GuestCtrlFsCbQueryInfoEx(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, PGSTCTLFSOBJINFO pFsObjInfo,
     2617                                               char *pszUser, char *pszGroups, void *pvACL, uint32_t cbACL)
     2618{
     2619    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2620    AssertPtrReturn(pFsObjInfo, VERR_INVALID_POINTER);
     2621    AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
     2622    AssertPtrReturn(pszGroups, VERR_INVALID_POINTER);
     2623    AssertPtrReturn(pvACL, VERR_INVALID_POINTER);
     2624    AssertReturn(cbACL, VERR_INVALID_PARAMETER);
     2625
     2626    HGCMReplyFsNotify Msg;
     2627    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_FS_NOTIFY, 4);
     2628    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
     2629    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_FS_NOTIFYTYPE_QUERY_INFO);
     2630    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
     2631    VbglHGCMParmPtrSet      (&Msg.u.queryinfo.obj_info, pFsObjInfo, sizeof(GSTCTLFSOBJINFO));
     2632    VbglHGCMParmPtrSetString(&Msg.u.queryinfo.user,   pszUser);
     2633    VbglHGCMParmPtrSetString(&Msg.u.queryinfo.groups, pszGroups);
     2634    VbglHGCMParmPtrSet      (&Msg.u.queryinfo.acl,    pvACL, cbACL);
     2635
     2636    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyDirNotify, u.read));
     2637}
     2638
     2639
     2640/**
     2641 * Replies to a HOST_MSG_FS_QUERY_INFO message.
     2642 *
     2643 * @returns VBox status code.
     2644 * @param   pCtx                Guest control command context to use.
     2645 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2646 * @param   pFsObjInfo          Guest file system object information to send.
     2647 */
     2648VBGLR3DECL(int) VbglR3GuestCtrlFsCbQueryInfo(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, PGSTCTLFSOBJINFO pFsObjInfo)
     2649{
     2650    char szIgnored[1];
     2651    return VbglR3GuestCtrlFsCbQueryInfoEx(pCtx, uRc, pFsObjInfo, szIgnored /* pszUser */, szIgnored /* pszGroups */,
     2652                                          szIgnored /* pvACL */, sizeof(szIgnored) /* cbACL */);
     2653}
     2654
     2655
     2656/**
     2657 * Replies to a HOST_MSG_FS_CREATE_TEMP message.
     2658 *
     2659 * @returns VBox status code.
     2660 * @param   pCtx                Guest control command context to use.
     2661 * @param   uRc                 Guest rc of operation (note: IPRT-style signed int).
     2662 * @param   pszPath             Path of created temporary file / directory, if \a uRc marks a success.
     2663 *                              Specify an empty path on failure -- NULL is not allowed!
     2664 */
     2665VBGLR3DECL(int) VbglR3GuestCtrlFsCbCreateTemp(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc, const char *pszPath)
     2666{
     2667    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
     2668    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
     2669
     2670    HGCMReplyFsNotify Msg;
     2671    VBGL_HGCM_HDR_INIT(&Msg.reply_hdr.hdr, pCtx->uClientID, GUEST_MSG_FS_NOTIFY, 4);
     2672    VbglHGCMParmUInt32Set(&Msg.reply_hdr.context, pCtx->uContextID);
     2673    VbglHGCMParmUInt32Set(&Msg.reply_hdr.type, GUEST_FS_NOTIFYTYPE_CREATE_TEMP);
     2674    VbglHGCMParmUInt32Set(&Msg.reply_hdr.rc, uRc);
     2675    VbglHGCMParmPtrSetString(&Msg.u.createtemp.path, pszPath);
     2676
     2677    return VbglR3HGCMCall(&Msg.reply_hdr.hdr, RT_UOFFSET_AFTER(HGCMReplyFsNotify, u.createtemp));
     2678}
     2679#endif /* VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS */
     2680
     2681
     2682/*********************************************************************************************************************************
     2683 * Process callbacks                                                                                                             *
     2684 ********************************************************************************************************************************/
     2685
    21302686/**
    21312687 * Callback for reporting a guest process status (along with some other stuff) to the host.
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