Changeset 70058 in vbox
- Timestamp:
- Dec 11, 2017 3:02:07 PM (7 years ago)
- svn:sync-xref-src-repo-rev:
- 119600
- Location:
- trunk
- Files:
-
- 11 edited
-
include/VBox/HostServices/GuestPropertySvc.h (modified) (11 diffs)
-
src/VBox/Additions/common/VBoxControl/VBoxControl.cpp (modified) (2 diffs)
-
src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp (modified) (1 diff)
-
src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestProp.cpp (modified) (9 diffs)
-
src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibVideo.cpp (modified) (2 diffs)
-
src/VBox/Additions/linux/lightdm-greeter/vbox-greeter.cpp (modified) (1 diff)
-
src/VBox/HostServices/GuestProperties/service.cpp (modified) (37 diffs)
-
src/VBox/HostServices/GuestProperties/testcase/tstGuestPropSvc.cpp (modified) (21 diffs)
-
src/VBox/Main/src-client/ConsoleImpl.cpp (modified) (7 diffs)
-
src/VBox/Main/src-client/ConsoleImpl2.cpp (modified) (7 diffs)
-
src/VBox/Main/src-server/MachineImpl.cpp (modified) (11 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/VBox/HostServices/GuestPropertySvc.h
r69107 r70058 35 35 #include <iprt/string.h> 36 36 37 /** Everything defined in this file lives in this namespace. */38 namespace guestProp {39 40 /******************************************************************************41 * Typedefs, constants and inlines *42 ******************************************************************************/43 37 44 38 /** Maximum length for property names */ 45 enum { MAX_NAME_LEN = 64 }; 39 #define GUEST_PROP_MAX_NAME_LEN 64 46 40 /** Maximum length for property values */ 47 enum { MAX_VALUE_LEN = 128 }; 41 #define GUEST_PROP_MAX_VALUE_LEN 128 48 42 /** Maximum number of properties per guest */ 49 enum { MAX_PROPS = 256 }; 43 #define GUEST_PROP_MAX_PROPS 256 50 44 /** Maximum size for enumeration patterns */ 51 enum { MAX_PATTERN_LEN = 1024 }; 45 #define GUEST_PROP_MAX_PATTERN_LEN 1024 52 46 /** Maximum number of changes we remember for guest notifications */ 53 enum { MAX_GUEST_NOTIFICATIONS = 256 }; 54 55 /** 56 * The guest property flag values which are currently accepted. 57 */ 58 enum ePropFlags 59 { 60 NILFLAG = 0, 61 /** Transient until VM gets shut down. */ 62 TRANSIENT = RT_BIT(1), 63 RDONLYGUEST = RT_BIT(2), 64 RDONLYHOST = RT_BIT(3), 65 /** Transient until VM gets a reset / restarts. 66 * Implies TRANSIENT. */ 67 TRANSRESET = RT_BIT(4), 68 READONLY = RDONLYGUEST | RDONLYHOST, 69 ALLFLAGS = TRANSIENT | READONLY | TRANSRESET 70 }; 47 #define GUEST_PROP_MAX_GUEST_NOTIFICATIONS 256 48 49 50 /** @name GUEST_PROP_F_XXX - The guest property flag values which are currently accepted. 51 * @{ 52 */ 53 #define GUEST_PROP_F_NILFLAG UINT32_C(0) 54 /** Transient until VM gets shut down. */ 55 #define GUEST_PROP_F_TRANSIENT RT_BIT_32(1) 56 #define GUEST_PROP_F_RDONLYGUEST RT_BIT_32(2) 57 #define GUEST_PROP_F_RDONLYHOST RT_BIT_32(3) 58 /** Transient until VM gets a reset / restarts. 59 * Implies TRANSIENT. */ 60 #define GUEST_PROP_F_TRANSRESET RT_BIT_32(4) 61 #define GUEST_PROP_F_READONLY (GUEST_PROP_F_RDONLYGUEST | GUEST_PROP_F_RDONLYHOST) 62 #define GUEST_PROP_F_ALLFLAGS (GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_READONLY | GUEST_PROP_F_TRANSRESET) 63 /** @} */ 71 64 72 65 /** … … 76 69 * list. 77 70 */ 78 DECLINLINE(const char *) flagName(uint32_t fFlag)71 DECLINLINE(const char *) GuestPropFlagName(uint32_t fFlag) 79 72 { 80 73 switch (fFlag) 81 74 { 82 case TRANSIENT:75 case GUEST_PROP_F_TRANSIENT: 83 76 return "TRANSIENT"; 84 case RDONLYGUEST:77 case GUEST_PROP_F_RDONLYGUEST: 85 78 return "RDONLYGUEST"; 86 case RDONLYHOST:79 case GUEST_PROP_F_RDONLYHOST: 87 80 return "RDONLYHOST"; 88 case READONLY:81 case GUEST_PROP_F_READONLY: 89 82 return "READONLY"; 90 case TRANSRESET:83 case GUEST_PROP_F_TRANSRESET: 91 84 return "TRANSRESET"; 92 85 default: … … 102 95 * list. 103 96 */ 104 DECLINLINE(size_t) flagNameLen(uint32_t fFlag)105 { 106 const char *pcszName = flagName(fFlag);97 DECLINLINE(size_t) GuestPropFlagNameLen(uint32_t fFlag) 98 { 99 const char *pcszName = GuestPropFlagName(fFlag); 107 100 return RT_LIKELY(pcszName != NULL) ? strlen(pcszName) : 0; 108 101 } … … 112 105 * RDONLYGUEST, RDONLYHOST and RDONLY 113 106 */ 114 enum { MAX_FLAGS_LEN = sizeof("TRANSIENT, RDONLYGUEST, TRANSRESET") }; 107 #define GUEST_PROP_MAX_FLAGS_LEN sizeof("TRANSIENT, RDONLYGUEST, TRANSRESET") 115 108 116 109 /** 117 110 * Parse a guest properties flags string for flag names and make sure that 118 111 * there is no junk text in the string. 112 * 119 113 * @returns IPRT status code 120 * @ret urns VERR_INVALID_PARAMif the flag string is not valid114 * @retval VERR_INVALID_PARAMETER if the flag string is not valid 121 115 * @param pcszFlags the flag string to parse 122 116 * @param pfFlags where to store the parse result. May not be NULL. … … 125 119 * its own library. 126 120 */ 127 DECLINLINE(int) validateFlags(const char *pcszFlags, uint32_t *pfFlags)121 DECLINLINE(int) GuestPropValidateFlags(const char *pcszFlags, uint32_t *pfFlags) 128 122 { 129 123 static const uint32_t s_aFlagList[] = 130 124 { 131 TRANSIENT, READONLY, RDONLYGUEST, RDONLYHOST,TRANSRESET125 GUEST_PROP_F_TRANSIENT, GUEST_PROP_F_READONLY, GUEST_PROP_F_RDONLYGUEST, GUEST_PROP_F_RDONLYHOST, GUEST_PROP_F_TRANSRESET 132 126 }; 133 127 const char *pcszNext = pcszFlags; … … 144 138 unsigned i = 0; 145 139 for (; i < RT_ELEMENTS(s_aFlagList); ++i) 146 if (RTStrNICmp(pcszNext, flagName(s_aFlagList[i]), 147 flagNameLen(s_aFlagList[i])) == 0) 140 if (RTStrNICmp(pcszNext, GuestPropFlagName(s_aFlagList[i]), GuestPropFlagNameLen(s_aFlagList[i])) == 0) 148 141 break; 149 142 if (RT_ELEMENTS(s_aFlagList) == i) … … 152 145 { 153 146 fFlags |= s_aFlagList[i]; 154 pcszNext += flagNameLen(s_aFlagList[i]);147 pcszNext += GuestPropFlagNameLen(s_aFlagList[i]); 155 148 while (' ' == *pcszNext) 156 149 ++pcszNext; … … 169 162 } 170 163 164 171 165 /** 172 166 * Write out flags to a string. … … 176 170 * a buffer of size (at least) MAX_FLAGS_LEN. 177 171 */ 178 DECLINLINE(int) writeFlags(uint32_t fFlags, char *pszFlags)172 DECLINLINE(int) GuestPropWriteFlags(uint32_t fFlags, char *pszFlags) 179 173 { 180 174 /* Putting READONLY before the other RDONLY flags keeps the result short. */ 181 175 static const uint32_t s_aFlagList[] = 182 176 { 183 TRANSIENT, READONLY, RDONLYGUEST, RDONLYHOST,TRANSRESET177 GUEST_PROP_F_TRANSIENT, GUEST_PROP_F_READONLY, GUEST_PROP_F_RDONLYGUEST, GUEST_PROP_F_RDONLYHOST, GUEST_PROP_F_TRANSRESET 184 178 }; 185 179 int rc = VINF_SUCCESS; 186 180 187 181 AssertLogRelReturn(VALID_PTR(pszFlags), VERR_INVALID_POINTER); 188 if ((fFlags & ~ ALLFLAGS) ==NILFLAG)182 if ((fFlags & ~GUEST_PROP_F_ALLFLAGS) == GUEST_PROP_F_NILFLAG) 189 183 { 184 char *pszNext; 185 190 186 /* TRANSRESET implies TRANSIENT. For compatability with old clients we 191 187 always set TRANSIENT when TRANSRESET appears. */ 192 if (fFlags & TRANSRESET)193 fFlags |= TRANSIENT;194 195 char *pszNext = pszFlags;188 if (fFlags & GUEST_PROP_F_TRANSRESET) 189 fFlags |= GUEST_PROP_F_TRANSIENT; 190 191 pszNext = pszFlags; 196 192 for (unsigned i = 0; i < RT_ELEMENTS(s_aFlagList); ++i) 197 193 { 198 194 if (s_aFlagList[i] == (fFlags & s_aFlagList[i])) 199 195 { 200 strcpy(pszNext, flagName(s_aFlagList[i]));201 pszNext += flagNameLen(s_aFlagList[i]);196 strcpy(pszNext, GuestPropFlagName(s_aFlagList[i])); 197 pszNext += GuestPropFlagNameLen(s_aFlagList[i]); 202 198 fFlags &= ~s_aFlagList[i]; 203 if (fFlags != NILFLAG)199 if (fFlags != GUEST_PROP_F_NILFLAG) 204 200 { 205 201 strcpy(pszNext, ", "); … … 210 206 *pszNext = '\0'; 211 207 212 Assert(fFlags == NILFLAG); /* bad s_aFlagList */208 Assert(fFlags == GUEST_PROP_F_NILFLAG); /* bad s_aFlagList */ 213 209 } 214 210 else … … 217 213 } 218 214 219 /** 220 * The service functions which are callable by host. 221 */ 222 enum eHostFn 223 { 224 /** 225 * Set properties in a block. The parameters are pointers to 226 * NULL-terminated arrays containing the parameters. These are, in order, 227 * name, value, timestamp, flags. Strings are stored as pointers to 228 * mutable utf8 data. All parameters must be supplied. 229 */ 230 SET_PROPS_HOST = 1, 231 /** 232 * Get the value attached to a guest property 233 * The parameter format matches that of GET_PROP. 234 */ 235 GET_PROP_HOST = 2, 236 /** 237 * Set the value attached to a guest property 238 * The parameter format matches that of SET_PROP. 239 */ 240 SET_PROP_HOST = 3, 241 /** 242 * Set the value attached to a guest property 243 * The parameter format matches that of SET_PROP_VALUE. 244 */ 245 SET_PROP_VALUE_HOST = 4, 246 /** 247 * Remove a guest property. 248 * The parameter format matches that of DEL_PROP. 249 */ 250 DEL_PROP_HOST = 5, 251 /** 252 * Enumerate guest properties. 253 * The parameter format matches that of ENUM_PROPS. 254 */ 255 ENUM_PROPS_HOST = 6, 256 257 /** 258 * Set global flags for the service. Currently RDONLYGUEST is supported. 259 * Takes one 32-bit unsigned integer parameter for the flags. 260 */ 261 SET_GLOBAL_FLAGS_HOST = 7, 262 263 /** 264 * Return the pointer to a debug info function enumerating all guest properties. 265 */ 266 GET_DBGF_INFO_FN = 8 267 }; 268 269 /** 270 * The service functions which are called by guest. The numbers may not change, 271 * so we hardcode them. 272 */ 273 enum eGuestFn 274 { 275 /** Get a guest property */ 276 GET_PROP = 1, 277 /** Set a guest property */ 278 SET_PROP = 2, 279 /** Set just the value of a guest property */ 280 SET_PROP_VALUE = 3, 281 /** Delete a guest property */ 282 DEL_PROP = 4, 283 /** Enumerate guest properties */ 284 ENUM_PROPS = 5, 285 /** Poll for guest notifications */ 286 GET_NOTIFICATION = 6 287 }; 288 289 /** 290 * Data structure to pass to the service extension callback. We use this to 291 * notify the host of changes to properties. 292 */ 293 typedef struct _HOSTCALLBACKDATA 294 { 295 /** Magic number to identify the structure */ 296 uint32_t u32Magic; 215 216 /** @name The service functions which are callable by host. 217 * @{ 218 */ 219 /** Set properties in a block. 220 * The parameters are pointers to NULL-terminated arrays containing the 221 * parameters. These are, in order, name, value, timestamp, flags. Strings are 222 * stored as pointers to mutable utf8 data. All parameters must be supplied. */ 223 #define GUEST_PROP_FN_SET_PROPS_HOST 1 224 /** Get the value attached to a guest property. 225 * The parameter format matches that of GET_PROP. */ 226 #define GUEST_PROP_FN_GET_PROP_HOST 2 227 /** Set the value attached to a guest property. 228 * The parameter format matches that of SET_PROP. */ 229 #define GUEST_PROP_FN_SET_PROP_HOST 3 230 /** Set the value attached to a guest property. 231 * The parameter format matches that of SET_PROP_VALUE. */ 232 #define GUEST_PROP_FN_SET_PROP_VALUE_HOST 4 233 /** Remove a guest property. 234 * The parameter format matches that of DEL_PROP. */ 235 #define GUEST_PROP_FN_DEL_PROP_HOST 5 236 /** Enumerate guest properties. 237 * The parameter format matches that of ENUM_PROPS. */ 238 #define GUEST_PROP_FN_ENUM_PROPS_HOST 6 239 /** Set global flags for the service. 240 * Currently RDONLYGUEST is supported. Takes one 32-bit unsigned integer 241 * parameter for the flags. */ 242 #define GUEST_PROP_FN_SET_GLOBAL_FLAGS_HOST 7 243 /** Return the pointer to a debug info function enumerating all guest 244 * properties. */ 245 #define GUEST_PROP_FN_GET_DBGF_INFO_FN 8 246 /** @} */ 247 248 249 /** @name The service functions which are called by guest. 250 * 251 * @note The numbers may not change! 252 * @{ 253 */ 254 /** Get a guest property */ 255 #define GUEST_PROP_FN_GET_PROP 1 256 /** Set a guest property */ 257 #define GUEST_PROP_FN_SET_PROP 2 258 /** Set just the value of a guest property */ 259 #define GUEST_PROP_FN_SET_PROP_VALUE 3 260 /** Delete a guest property */ 261 #define GUEST_PROP_FN_DEL_PROP 4 262 /** Enumerate guest properties */ 263 #define GUEST_PROP_FN_ENUM_PROPS 5 264 /** Poll for guest notifications */ 265 #define GUEST_PROP_FN_GET_NOTIFICATION 6 266 /** @} */ 267 268 269 /** 270 * Data structure to pass to the service extension callback. 271 * We use this to notify the host of changes to properties. 272 */ 273 typedef struct GUESTPROPHOSTCALLBACKDATA 274 { 275 /** Magic number to identify the structure (GUESTPROPHOSTCALLBACKDATA_MAGIC). */ 276 uint32_t u32Magic; 297 277 /** The name of the property that was changed */ 298 const char *pcszName;278 const char *pcszName; 299 279 /** The new property value, or NULL if the property was deleted */ 300 const char *pcszValue;280 const char *pcszValue; 301 281 /** The timestamp of the modification */ 302 uint64_t u64Timestamp;282 uint64_t u64Timestamp; 303 283 /** The flags field of the modified property */ 304 const char *pcszFlags; 305 } HOSTCALLBACKDATA, *PHOSTCALLBACKDATA; 306 307 enum 308 { 309 /** Magic number for sanity checking the HOSTCALLBACKDATA structure */ 310 HOSTCALLBACKMAGIC = 0x69c87a78 311 }; 284 const char *pcszFlags; 285 } GUESTPROPHOSTCALLBACKDATA; 286 /** Poitner to a data structure to pass to the service extension callback. */ 287 typedef GUESTPROPHOSTCALLBACKDATA *PGUESTPROPHOSTCALLBACKDATA; 288 289 /** Magic number for sanity checking the HOSTCALLBACKDATA structure */ 290 #define GUESTPROPHOSTCALLBACKDATA_MAGIC UINT32_C(0x69c87a78) 291 292 /** Everything defined in this file lives in this namespace. */ 293 namespace guestProp { 312 294 313 295 /** -
trunk/src/VBox/Additions/common/VBoxControl/VBoxControl.cpp
r69500 r70058 1189 1189 * of space here in case the maximum values are raised. */ 1190 1190 void *pvBuf = NULL; 1191 uint32_t cbBuf = MAX_VALUE_LEN +MAX_FLAGS_LEN + 1024;1191 uint32_t cbBuf = GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN + 1024; 1192 1192 if (RT_SUCCESS(rc)) 1193 1193 { … … 1497 1497 * of space here in case the maximum values are raised. */ 1498 1498 void *pvBuf = NULL; 1499 uint32_t cbBuf = MAX_NAME_LEN + MAX_VALUE_LEN +MAX_FLAGS_LEN + 1024;1499 uint32_t cbBuf = GUEST_PROP_MAX_NAME_LEN + GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN + 1024; 1500 1500 /* Because there is a race condition between our reading the size of a 1501 1501 * property and the guest updating it, we loop a few times here and -
trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp
r70040 r70058 1325 1325 */ 1326 1326 uint32_t fFlags = 0; 1327 rc = guestProp::validateFlags(apszFields[3], &fFlags);1327 rc = GuestPropValidateFlags(apszFields[3], &fFlags); 1328 1328 if (RT_SUCCESS(rc)) 1329 1329 { 1330 if (fFlags & guestProp::RDONLYGUEST)1330 if (fFlags & GUEST_PROP_F_RDONLYGUEST) 1331 1331 { 1332 1332 apszFields[0] += sizeof(g_szzPattern) - 2; -
trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibGuestProp.cpp
r69500 r70058 165 165 { 166 166 SetProperty Msg; 167 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, SET_PROP_VALUE, 3);167 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_SET_PROP_VALUE, 3); 168 168 VbglHGCMParmPtrSetString(&Msg.name, pszName); 169 169 VbglHGCMParmPtrSetString(&Msg.value, pszValue); … … 174 174 { 175 175 DelProperty Msg; 176 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, DEL_PROP, 1);176 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_DEL_PROP, 1); 177 177 VbglHGCMParmPtrSetString(&Msg.name, pszName); 178 178 rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg)); … … 202 202 { 203 203 SetPropertyValue Msg; 204 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, SET_PROP_VALUE, 2);204 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_SET_PROP_VALUE, 2); 205 205 VbglHGCMParmPtrSetString(&Msg.name, pszName); 206 206 VbglHGCMParmPtrSetString(&Msg.value, pszValue); … … 210 210 { 211 211 DelProperty Msg; 212 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, DEL_PROP, 1);212 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_DEL_PROP, 1); 213 213 VbglHGCMParmPtrSetString(&Msg.name, pszName); 214 214 rc = VbglR3HGCMCall(&Msg.hdr, sizeof(Msg)); … … 298 298 */ 299 299 GetProperty Msg; 300 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, G ET_PROP, 4);300 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_GET_PROP, 4); 301 301 VbglHGCMParmPtrSetString(&Msg.name, pszName); 302 302 VbglHGCMParmPtrSet(&Msg.buffer, pvBuf, cbBuf); … … 387 387 char *pszValue = NULL; 388 388 void *pvBuf = NULL; 389 uint32_t c chBuf =MAX_VALUE_LEN;389 uint32_t cbBuf = GUEST_PROP_MAX_VALUE_LEN; 390 390 int rc = VERR_BUFFER_OVERFLOW; 391 391 for (unsigned i = 0; i < 10 && rc == VERR_BUFFER_OVERFLOW; ++i) 392 392 { 393 393 /* We leave a bit of space here in case the maximum value is raised. */ 394 c chBuf += 1024;395 void *pvTmpBuf = RTMemRealloc(pvBuf, c chBuf);394 cbBuf += 1024; 395 void *pvTmpBuf = RTMemRealloc(pvBuf, cbBuf); 396 396 if (pvTmpBuf) 397 397 { 398 398 pvBuf = pvTmpBuf; 399 rc = VbglR3GuestPropRead(idClient, pszName, pvBuf, cchBuf, 400 &pszValue, NULL, NULL, &cchBuf); 399 rc = VbglR3GuestPropRead(idClient, pszName, pvBuf, cbBuf, &pszValue, NULL, NULL, &cbBuf); 401 400 } 402 401 else … … 494 493 { 495 494 EnumProperties Msg; 496 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, ENUM_PROPS, 3);495 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_ENUM_PROPS, 3); 497 496 498 497 /* Get the length of the patterns array... */ … … 759 758 760 759 DelProperty Msg; 761 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, DEL_PROP, 1);760 VBGL_HGCM_HDR_INIT(&Msg.hdr, idClient, GUEST_PROP_FN_DEL_PROP, 1); 762 761 VbglHGCMParmPtrSetString(&Msg.name, pszName); 763 762 return VbglR3HGCMCall(&Msg.hdr, sizeof(Msg)); … … 861 860 */ 862 861 GetNotification Msg; 863 VBGL_HGCM_HDR_INIT_TIMED(&Msg.hdr, idClient, G ET_NOTIFICATION, 4, cMillies);862 VBGL_HGCM_HDR_INIT_TIMED(&Msg.hdr, idClient, GUEST_PROP_FN_GET_NOTIFICATION, 4, cMillies); 864 863 865 864 VbglHGCMParmPtrSetString(&Msg.patterns, pszPatterns); -
trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibVideo.cpp
r69500 r70058 385 385 { 386 386 int rc2; 387 char szModeName[ MAX_NAME_LEN];388 char szModeParms[ MAX_VALUE_LEN];387 char szModeName[GUEST_PROP_MAX_NAME_LEN]; 388 char szModeParms[GUEST_PROP_MAX_VALUE_LEN]; 389 389 RTStrPrintf(szModeName, sizeof(szModeName), VIDEO_PROP_PREFIX "%u", idScreen); 390 390 RTStrPrintf(szModeParms, sizeof(szModeParms), "%ux%ux%u,%ux%u,%u", cx, cy, cBits, x, y, (unsigned) fEnabled); … … 471 471 * something is wrong with the data stored in the property. */ 472 472 char szModeParms[1024]; 473 char szModeName[ MAX_NAME_LEN]; /** @todo add a VbglR3GuestPropReadValueF/FV that does the RTStrPrintf for you. */473 char szModeName[GUEST_PROP_MAX_NAME_LEN]; /** @todo add a VbglR3GuestPropReadValueF/FV that does the RTStrPrintf for you. */ 474 474 RTStrPrintf(szModeName, sizeof(szModeName), VIDEO_PROP_PREFIX "%u", idScreen); 475 475 rc = VbglR3GuestPropReadValue(idClient, szModeName, szModeParms, sizeof(szModeParms), NULL); -
trunk/src/VBox/Additions/linux/lightdm-greeter/vbox-greeter.cpp
r69749 r70058 217 217 * of space here in case the maximum values are raised. */ 218 218 void *pvBuf = NULL; 219 uint32_t cbBuf = MAX_VALUE_LEN +MAX_FLAGS_LEN + _1K;219 uint32_t cbBuf = GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN + _1K; 220 220 221 221 /* Because there is a race condition between our reading the size of a -
trunk/src/VBox/HostServices/GuestProperties/service.cpp
r69500 r70058 80 80 81 81 /** Default constructor */ 82 Property() : mTimestamp(0), mFlags( NILFLAG)82 Property() : mTimestamp(0), mFlags(GUEST_PROP_F_NILFLAG) 83 83 { 84 84 RT_ZERO(mStrCore); … … 171 171 PVBOXHGCMSVCHELPERS mpHelpers; 172 172 /** Global flags for the service */ 173 ePropFlags meGlobalFlags;173 uint32_t mfGlobalFlags; 174 174 /** The property string space handle. */ 175 175 RTSTRSPACE mhProperties; … … 255 255 * @retval VINF_PERMISSION_DENIED if the side is globally marked read-only. 256 256 * 257 * @param eFlags the flags on the property in question257 * @param fFlags the flags on the property in question 258 258 * @param isGuest is the guest or the host trying to make the change? 259 259 */ 260 int checkPermission( ePropFlags eFlags, bool isGuest)261 { 262 if ( eFlags & (isGuest ? RDONLYGUEST :RDONLYHOST))260 int checkPermission(uint32_t fFlags, bool isGuest) 261 { 262 if (fFlags & (isGuest ? GUEST_PROP_F_RDONLYGUEST : GUEST_PROP_F_RDONLYHOST)) 263 263 return VERR_PERMISSION_DENIED; 264 if (isGuest && (m eGlobalFlags &RDONLYGUEST))264 if (isGuest && (mfGlobalFlags & GUEST_PROP_F_RDONLYGUEST)) 265 265 return VINF_PERMISSION_DENIED; 266 266 return VINF_SUCCESS; … … 282 282 explicit Service(PVBOXHGCMSVCHELPERS pHelpers) 283 283 : mpHelpers(pHelpers) 284 , m eGlobalFlags(NILFLAG)284 , mfGlobalFlags(GUEST_PROP_F_NILFLAG) 285 285 , mhProperties(NULL) 286 286 , mcProperties(0) … … 526 526 { 527 527 uint32_t fFlagsIgn; 528 rc = validateFlags(papszFlags[i], &fFlagsIgn);528 rc = GuestPropValidateFlags(papszFlags[i], &fFlagsIgn); 529 529 } 530 530 } … … 537 537 { 538 538 uint32_t fFlags; 539 rc = validateFlags(papszFlags[i], &fFlags);539 rc = GuestPropValidateFlags(papszFlags[i], &fFlags); 540 540 AssertRCBreak(rc); 541 541 … … 618 618 if (pProp) 619 619 { 620 char szFlags[ MAX_FLAGS_LEN];621 rc = writeFlags(pProp->mFlags, szFlags);620 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 621 rc = GuestPropWriteFlags(pProp->mFlags, szFlags); 622 622 if (RT_SUCCESS(rc)) 623 623 { … … 672 672 uint32_t cchValue = 0; /* ditto */ 673 673 uint32_t cchFlags = 0; 674 uint32_t fFlags = NILFLAG;674 uint32_t fFlags = GUEST_PROP_F_NILFLAG; 675 675 uint64_t u64TimeNano = getCurrentTimestamp(); 676 676 … … 702 702 RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED); 703 703 if ((3 == cParms) && RT_SUCCESS(rc)) 704 rc = validateFlags(pcszFlags, &fFlags);704 rc = GuestPropValidateFlags(pcszFlags, &fFlags); 705 705 if (RT_FAILURE(rc)) 706 706 { … … 714 714 */ 715 715 Property *pProp = getPropertyInternal(pcszName); 716 rc = checkPermission(pProp ? (ePropFlags)pProp->mFlags :NILFLAG, isGuest);716 rc = checkPermission(pProp ? pProp->mFlags : GUEST_PROP_F_NILFLAG, isGuest); 717 717 if (rc == VINF_SUCCESS) 718 718 { … … 726 726 pProp->mFlags = fFlags; 727 727 } 728 else if (mcProperties < MAX_PROPS)728 else if (mcProperties < GUEST_PROP_MAX_PROPS) 729 729 { 730 730 try … … 806 806 Property *pProp = getPropertyInternal(pcszName); 807 807 if (pProp) 808 rc = checkPermission( (ePropFlags)pProp->mFlags, isGuest);808 rc = checkPermission(pProp->mFlags, isGuest); 809 809 810 810 /* … … 856 856 size_t const cbTimestamp = RTStrFormatNumber(szTimestamp, pProp->mTimestamp, 10, 0, 0, 0) + 1; 857 857 858 char szFlags[ MAX_FLAGS_LEN];859 int rc = writeFlags(pProp->mFlags, szFlags);858 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 859 int rc = GuestPropWriteFlags(pProp->mFlags, szFlags); 860 860 if (RT_FAILURE(rc)) 861 861 return rc; … … 922 922 ) 923 923 rc = VERR_INVALID_PARAMETER; 924 if (RT_SUCCESS(rc) && cbPatterns > MAX_PATTERN_LEN)924 if (RT_SUCCESS(rc) && cbPatterns > GUEST_PROP_MAX_PATTERN_LEN) 925 925 rc = VERR_TOO_MUCH_DATA; 926 926 … … 928 928 * First repack the patterns into the format expected by RTStrSimplePatternMatch() 929 929 */ 930 char szPatterns[ MAX_PATTERN_LEN];930 char szPatterns[GUEST_PROP_MAX_PATTERN_LEN]; 931 931 if (RT_SUCCESS(rc)) 932 932 { … … 1015 1015 if (RT_SUCCESS(rc)) 1016 1016 { 1017 char szFlags[ MAX_FLAGS_LEN];1018 rc = writeFlags(prop.mFlags, szFlags);1017 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 1018 rc = GuestPropWriteFlags(prop.mFlags, szFlags); 1019 1019 if (RT_SUCCESS(rc)) 1020 1020 { … … 1113 1113 } 1114 1114 1115 mGuestWaiters.push_back(GuestCall(u32ClientId, callHandle, G ET_NOTIFICATION,1115 mGuestWaiters.push_back(GuestCall(u32ClientId, callHandle, GUEST_PROP_FN_GET_NOTIFICATION, 1116 1116 cParms, paParms, rc)); 1117 1117 rc = VINF_HGCM_ASYNC_EXECUTE; … … 1195 1195 /** @todo r=andy This list does not have a purpose but for tracking 1196 1196 * the timestamps ... */ 1197 if (mGuestNotifications.size() > MAX_GUEST_NOTIFICATIONS)1197 if (mGuestNotifications.size() > GUEST_PROP_MAX_GUEST_NOTIFICATIONS) 1198 1198 mGuestNotifications.pop_front(); 1199 1199 } … … 1212 1212 if (pProp) 1213 1213 { 1214 char szFlags[ MAX_FLAGS_LEN];1214 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 1215 1215 /* Send out a host notification */ 1216 1216 const char *pszValue = prop.mValue.c_str(); 1217 rc = writeFlags(prop.mFlags, szFlags);1217 rc = GuestPropWriteFlags(prop.mFlags, szFlags); 1218 1218 if (RT_SUCCESS(rc)) 1219 1219 rc = notifyHost(pszProperty, pszValue, u64Timestamp, szFlags); … … 1237 1237 static DECLCALLBACK(void) notifyHostAsyncWorker(PFNHGCMSVCEXT pfnHostCallback, 1238 1238 void *pvHostData, 1239 HOSTCALLBACKDATA *pHostCallbackData)1239 PGUESTPROPHOSTCALLBACKDATA pHostCallbackData) 1240 1240 { 1241 1241 pfnHostCallback(pvHostData, 0 /*u32Function*/, 1242 1242 (void *)pHostCallbackData, 1243 sizeof( HOSTCALLBACKDATA));1243 sizeof(GUESTPROPHOSTCALLBACKDATA)); 1244 1244 RTMemFree(pHostCallbackData); 1245 1245 } … … 1266 1266 size_t cbValue = pszValue? strlen(pszValue): 0; 1267 1267 size_t cbFlags = pszFlags? strlen(pszFlags): 0; 1268 size_t cbAlloc = sizeof( HOSTCALLBACKDATA) + cbName + cbValue + cbFlags + 3;1269 HOSTCALLBACKDATA *pHostCallbackData = (HOSTCALLBACKDATA *)RTMemAlloc(cbAlloc);1268 size_t cbAlloc = sizeof(GUESTPROPHOSTCALLBACKDATA) + cbName + cbValue + cbFlags + 3; 1269 PGUESTPROPHOSTCALLBACKDATA pHostCallbackData = (PGUESTPROPHOSTCALLBACKDATA)RTMemAlloc(cbAlloc); 1270 1270 if (pHostCallbackData) 1271 1271 { 1272 1272 uint8_t *pu8 = (uint8_t *)pHostCallbackData; 1273 pu8 += sizeof( HOSTCALLBACKDATA);1274 1275 pHostCallbackData->u32Magic = HOSTCALLBACKMAGIC;1273 pu8 += sizeof(GUESTPROPHOSTCALLBACKDATA); 1274 1275 pHostCallbackData->u32Magic = GUESTPROPHOSTCALLBACKDATA_MAGIC; 1276 1276 1277 1277 pHostCallbackData->pcszName = (const char *)pu8; … … 1305 1305 } 1306 1306 #else 1307 HOSTCALLBACKDATA HostCallbackData;1308 HostCallbackData.u32Magic = HOSTCALLBACKMAGIC;1307 GUESTPROPHOSTCALLBACKDATA HostCallbackData; 1308 HostCallbackData.u32Magic = GUESTPROPHOSTCALLBACKDATA_MAGIC; 1309 1309 HostCallbackData.pcszName = pszName; 1310 1310 HostCallbackData.pcszValue = pszValue; … … 1342 1342 { 1343 1343 /* The guest wishes to read a property */ 1344 case G ET_PROP:1344 case GUEST_PROP_FN_GET_PROP: 1345 1345 LogFlowFunc(("GET_PROP\n")); 1346 1346 rc = getProperty(cParms, paParms); … … 1348 1348 1349 1349 /* The guest wishes to set a property */ 1350 case SET_PROP:1350 case GUEST_PROP_FN_SET_PROP: 1351 1351 LogFlowFunc(("SET_PROP\n")); 1352 1352 rc = setProperty(cParms, paParms, true); … … 1354 1354 1355 1355 /* The guest wishes to set a property value */ 1356 case SET_PROP_VALUE:1356 case GUEST_PROP_FN_SET_PROP_VALUE: 1357 1357 LogFlowFunc(("SET_PROP_VALUE\n")); 1358 1358 rc = setProperty(cParms, paParms, true); … … 1360 1360 1361 1361 /* The guest wishes to remove a configuration value */ 1362 case DEL_PROP:1362 case GUEST_PROP_FN_DEL_PROP: 1363 1363 LogFlowFunc(("DEL_PROP\n")); 1364 1364 rc = delProperty(cParms, paParms, true); … … 1366 1366 1367 1367 /* The guest wishes to enumerate all properties */ 1368 case ENUM_PROPS:1368 case GUEST_PROP_FN_ENUM_PROPS: 1369 1369 LogFlowFunc(("ENUM_PROPS\n")); 1370 1370 rc = enumProps(cParms, paParms); … … 1372 1372 1373 1373 /* The guest wishes to get the next property notification */ 1374 case G ET_NOTIFICATION:1374 case GUEST_PROP_FN_GET_NOTIFICATION: 1375 1375 LogFlowFunc(("GET_NOTIFICATION\n")); 1376 1376 rc = getNotification(u32ClientID, callHandle, cParms, paParms); … … 1405 1405 PCDBGFINFOHLP pHlp = ((ENUMDBGINFO*)pvUser)->pHlp; 1406 1406 1407 char szFlags[ MAX_FLAGS_LEN];1408 int rc = writeFlags(pProp->mFlags, szFlags);1407 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 1408 int rc = GuestPropWriteFlags(pProp->mFlags, szFlags); 1409 1409 if (RT_FAILURE(rc)) 1410 1410 RTStrPrintf(szFlags, sizeof(szFlags), "???"); … … 1456 1456 { 1457 1457 /* The host wishes to set a block of properties */ 1458 case SET_PROPS_HOST:1458 case GUEST_PROP_FN_SET_PROPS_HOST: 1459 1459 LogFlowFunc(("SET_PROPS_HOST\n")); 1460 1460 rc = setPropertyBlock(cParms, paParms); … … 1462 1462 1463 1463 /* The host wishes to read a configuration value */ 1464 case G ET_PROP_HOST:1464 case GUEST_PROP_FN_GET_PROP_HOST: 1465 1465 LogFlowFunc(("GET_PROP_HOST\n")); 1466 1466 rc = getProperty(cParms, paParms); … … 1468 1468 1469 1469 /* The host wishes to set a configuration value */ 1470 case SET_PROP_HOST:1470 case GUEST_PROP_FN_SET_PROP_HOST: 1471 1471 LogFlowFunc(("SET_PROP_HOST\n")); 1472 1472 rc = setProperty(cParms, paParms, false); … … 1474 1474 1475 1475 /* The host wishes to set a configuration value */ 1476 case SET_PROP_VALUE_HOST:1476 case GUEST_PROP_FN_SET_PROP_VALUE_HOST: 1477 1477 LogFlowFunc(("SET_PROP_VALUE_HOST\n")); 1478 1478 rc = setProperty(cParms, paParms, false); … … 1480 1480 1481 1481 /* The host wishes to remove a configuration value */ 1482 case DEL_PROP_HOST:1482 case GUEST_PROP_FN_DEL_PROP_HOST: 1483 1483 LogFlowFunc(("DEL_PROP_HOST\n")); 1484 1484 rc = delProperty(cParms, paParms, false); … … 1486 1486 1487 1487 /* The host wishes to enumerate all properties */ 1488 case ENUM_PROPS_HOST:1488 case GUEST_PROP_FN_ENUM_PROPS_HOST: 1489 1489 LogFlowFunc(("ENUM_PROPS\n")); 1490 1490 rc = enumProps(cParms, paParms); … … 1492 1492 1493 1493 /* The host wishes to set global flags for the service */ 1494 case SET_GLOBAL_FLAGS_HOST:1494 case GUEST_PROP_FN_SET_GLOBAL_FLAGS_HOST: 1495 1495 LogFlowFunc(("SET_GLOBAL_FLAGS_HOST\n")); 1496 1496 if (cParms == 1) 1497 1497 { 1498 uint32_t eFlags;1499 rc = paParms[0].getUInt32(& eFlags);1498 uint32_t fFlags; 1499 rc = paParms[0].getUInt32(&fFlags); 1500 1500 if (RT_SUCCESS(rc)) 1501 m eGlobalFlags = (ePropFlags)eFlags;1501 mfGlobalFlags = fFlags; 1502 1502 } 1503 1503 else … … 1505 1505 break; 1506 1506 1507 case G ET_DBGF_INFO_FN:1507 case GUEST_PROP_FN_GET_DBGF_INFO_FN: 1508 1508 if (cParms != 2) 1509 1509 return VERR_INVALID_PARAMETER; -
trunk/src/VBox/HostServices/GuestProperties/testcase/tstGuestPropSvc.cpp
r69500 r70058 106 106 { 107 107 int rc = VINF_SUCCESS; 108 char *pszFlagBuffer = (char *)RTTestGuardedAllocTail(g_hTest, MAX_FLAGS_LEN);108 char *pszFlagBuffer = (char *)RTTestGuardedAllocTail(g_hTest, GUEST_PROP_MAX_FLAGS_LEN); 109 109 110 110 RTTestISub("Conversion of valid flags strings"); … … 112 112 { 113 113 uint32_t fFlags; 114 rc = validateFlags(g_aValidFlagStrings[i].pcszIn, &fFlags);114 rc = GuestPropValidateFlags(g_aValidFlagStrings[i].pcszIn, &fFlags); 115 115 if (RT_FAILURE(rc)) 116 116 RTTestIFailed("Failed to validate flag string '%s'", g_aValidFlagStrings[i].pcszIn); 117 117 if (RT_SUCCESS(rc)) 118 118 { 119 rc = writeFlags(fFlags, pszFlagBuffer);119 rc = GuestPropWriteFlags(fFlags, pszFlagBuffer); 120 120 if (RT_FAILURE(rc)) 121 121 RTTestIFailed("Failed to convert flag string '%s' back to a string.", 122 122 g_aValidFlagStrings[i].pcszIn); 123 123 } 124 if (RT_SUCCESS(rc) && (strlen(pszFlagBuffer) > MAX_FLAGS_LEN - 1))124 if (RT_SUCCESS(rc) && (strlen(pszFlagBuffer) > GUEST_PROP_MAX_FLAGS_LEN - 1)) 125 125 { 126 126 RTTestIFailed("String '%s' converts back to a flag string which is too long.\n", … … 143 143 uint32_t fFlags; 144 144 /* This is required to fail. */ 145 if (RT_SUCCESS( validateFlags(g_apszInvalidFlagStrings[i], &fFlags)))145 if (RT_SUCCESS(GuestPropValidateFlags(g_apszInvalidFlagStrings[i], &fFlags))) 146 146 { 147 147 RTTestIFailed("String '%s' was incorrectly accepted as a valid flag string.\n", … … 153 153 if (RT_SUCCESS(rc)) 154 154 { 155 uint32_t u32BadFlags = ALLFLAGS << 1;155 uint32_t u32BadFlags = GUEST_PROP_F_ALLFLAGS << 1; 156 156 RTTestISub("Rejection of an invalid flags field"); 157 157 /* This is required to fail. */ 158 if (RT_SUCCESS( writeFlags(u32BadFlags, pszFlagBuffer)))158 if (RT_SUCCESS(GuestPropWriteFlags(u32BadFlags, pszFlagBuffer))) 159 159 { 160 160 RTTestIFailed("Flags 0x%x were incorrectly written out as '%.*s'\n", 161 u32BadFlags, MAX_FLAGS_LEN, pszFlagBuffer);161 u32BadFlags, GUEST_PROP_MAX_FLAGS_LEN, pszFlagBuffer); 162 162 rc = VERR_PARSE_ERROR; 163 163 } … … 226 226 aParms[2].setPointer((void *)g_au64TimestampBlock, 0); 227 227 aParms[3].setPointer((void *)g_apcszFlagsBlock, 0); 228 RTTESTI_CHECK_RC(ptable->pfnHostCall(ptable->pvService, SET_PROPS_HOST, 4, &aParms[0]), VINF_SUCCESS);228 RTTESTI_CHECK_RC(ptable->pfnHostCall(ptable->pvService, GUEST_PROP_FN_SET_PROPS_HOST, 4, &aParms[0]), VINF_SUCCESS); 229 229 } 230 230 … … 337 337 aParms[1].setPointer((void *)abBuffer, g_aEnumStrings[i].cbBuffer - 1); 338 338 memset(abBuffer, 0x55, sizeof(abBuffer)); 339 int rc2 = ptable->pfnHostCall(ptable->pvService, ENUM_PROPS_HOST, 3, aParms);339 int rc2 = ptable->pfnHostCall(ptable->pvService, GUEST_PROP_FN_ENUM_PROPS_HOST, 3, aParms); 340 340 if (rc2 == VERR_BUFFER_OVERFLOW) 341 341 { … … 353 353 aParms[1].setPointer((void *)abBuffer, g_aEnumStrings[i].cbBuffer); 354 354 memset(abBuffer, 0x55, sizeof(abBuffer)); 355 rc2 = ptable->pfnHostCall(ptable->pvService, ENUM_PROPS_HOST, 3, aParms);355 rc2 = ptable->pfnHostCall(ptable->pvService, GUEST_PROP_FN_ENUM_PROPS_HOST, 3, aParms); 356 356 if (rc2 == VINF_SUCCESS) 357 357 { … … 394 394 { 395 395 VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS }; 396 int command = SET_PROP_VALUE;396 int command = GUEST_PROP_FN_SET_PROP_VALUE; 397 397 if (isHost) 398 398 { 399 399 if (useSetProp) 400 command = SET_PROP_HOST;400 command = GUEST_PROP_FN_SET_PROP_HOST; 401 401 else 402 command = SET_PROP_VALUE_HOST;402 command = GUEST_PROP_FN_SET_PROP_VALUE_HOST; 403 403 } 404 404 else if (useSetProp) 405 command = SET_PROP;405 command = GUEST_PROP_FN_SET_PROP; 406 406 VBOXHGCMSVCPARM aParms[3]; 407 407 /* Work around silly constant issues - we ought to allow passing 408 408 * constant strings in the hgcm parameters. */ 409 char szName[ MAX_NAME_LEN];410 char szValue[ MAX_VALUE_LEN];411 char szFlags[ MAX_FLAGS_LEN];409 char szName[GUEST_PROP_MAX_NAME_LEN]; 410 char szValue[GUEST_PROP_MAX_VALUE_LEN]; 411 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 412 412 RTStrPrintf(szName, sizeof(szName), "%s", pcszName); 413 413 RTStrPrintf(szValue, sizeof(szValue), "%s", pcszValue); … … 493 493 { 494 494 VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS }; 495 int command = DEL_PROP;495 int command = GUEST_PROP_FN_DEL_PROP; 496 496 if (isHost) 497 command = DEL_PROP_HOST;497 command = GUEST_PROP_FN_DEL_PROP_HOST; 498 498 VBOXHGCMSVCPARM aParms[1]; 499 499 aParms[0].setString(pcszName); … … 595 595 /* Work around silly constant issues - we ought to allow passing 596 596 * constant strings in the hgcm parameters. */ 597 char szBuffer[ MAX_VALUE_LEN +MAX_FLAGS_LEN];597 char szBuffer[GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN]; 598 598 RTTESTI_CHECK_RETV(s_aGetProperties[i].cchValue < sizeof(szBuffer)); 599 599 … … 601 601 memset(szBuffer, 0x55, sizeof(szBuffer)); 602 602 aParms[1].setPointer(szBuffer, sizeof(szBuffer)); 603 int rc2 = pTable->pfnHostCall(pTable->pvService, G ET_PROP_HOST, 4, aParms);603 int rc2 = pTable->pfnHostCall(pTable->pvService, GUEST_PROP_FN_GET_PROP_HOST, 4, aParms); 604 604 605 605 if (s_aGetProperties[i].exists && RT_FAILURE(rc2)) … … 689 689 aParms[1].setUInt64(1); 690 690 aParms[2].setPointer(pvBuf, cbBuf); 691 pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL, G ET_NOTIFICATION, 4, aParms);691 pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL, GUEST_PROP_FN_GET_NOTIFICATION, 4, aParms); 692 692 693 693 if ( callHandle.rc != VERR_BUFFER_OVERFLOW … … 715 715 aParms[1].setUInt64(u64Timestamp); 716 716 aParms[2].setPointer(pvBuf, cbBuf); 717 pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL, G ET_NOTIFICATION, 4, aParms);717 pTable->pfnCall(pTable->pvService, &callHandle, 0, NULL, GUEST_PROP_FN_GET_NOTIFICATION, 4, aParms); 718 718 if ( RT_FAILURE(callHandle.rc) 719 719 || (i == 0 && callHandle.rc != VWRN_NOT_FOUND) … … 737 737 VBOXHGCMSVCPARM aParms[4]; 738 738 /** Result buffer */ 739 char abBuffer[ MAX_NAME_LEN + MAX_VALUE_LEN +MAX_FLAGS_LEN];739 char abBuffer[GUEST_PROP_MAX_NAME_LEN + GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN]; 740 740 /** Return value */ 741 741 VBOXHGCMCALLHANDLE_TYPEDEF callHandle; … … 756 756 g_AsyncNotification.callHandle.rc = VINF_HGCM_ASYNC_EXECUTE; 757 757 pTable->pfnCall(pTable->pvService, &g_AsyncNotification.callHandle, 0, NULL, 758 G ET_NOTIFICATION, 4, g_AsyncNotification.aParms);758 GUEST_PROP_FN_GET_NOTIFICATION, 4, g_AsyncNotification.aParms); 759 759 if (RT_FAILURE(g_AsyncNotification.callHandle.rc)) 760 760 RTTestIFailed("GET_NOTIFICATION call failed, rc=%Rrc.", g_AsyncNotification.callHandle.rc); … … 815 815 * 816 816 * @param pTable the service instance handle 817 * @param eFlags the flags to set818 */ 819 static int doSetGlobalFlags(VBOXHGCMSVCFNTABLE *pTable, ePropFlags eFlags)817 * @param fFlags the flags to set 818 */ 819 static int doSetGlobalFlags(VBOXHGCMSVCFNTABLE *pTable, uint32_t fFlags) 820 820 { 821 821 VBOXHGCMSVCPARM paParm; 822 paParm.setUInt32( eFlags);823 int rc = pTable->pfnHostCall(pTable->pvService, SET_GLOBAL_FLAGS_HOST, 1, &paParm);822 paParm.setUInt32(fFlags); 823 int rc = pTable->pfnHostCall(pTable->pvService, GUEST_PROP_FN_SET_GLOBAL_FLAGS_HOST, 1, &paParm); 824 824 if (RT_FAILURE(rc)) 825 825 { 826 char szFlags[ MAX_FLAGS_LEN];827 if (RT_FAILURE( writeFlags(eFlags, szFlags)))826 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 827 if (RT_FAILURE(GuestPropWriteFlags(fFlags, szFlags))) 828 828 RTTestIFailed("Failed to set the global flags."); 829 829 else … … 874 874 875 875 RTTESTI_CHECK_RC_OK_RETV(VBoxHGCMSvcLoad(pTable)); 876 int rc = doSetGlobalFlags(pTable, RDONLYGUEST);876 int rc = doSetGlobalFlags(pTable, GUEST_PROP_F_RDONLYGUEST); 877 877 if (RT_SUCCESS(rc)) 878 878 { … … 942 942 943 943 RTTESTI_CHECK_RC_OK_RETV(VBoxHGCMSvcLoad(pTable)); 944 int rc = doSetGlobalFlags(pTable, RDONLYGUEST);944 int rc = doSetGlobalFlags(pTable, GUEST_PROP_F_RDONLYGUEST); 945 945 if (RT_SUCCESS(rc)) 946 946 { … … 1006 1006 aParms[0].setString(s_szProp); 1007 1007 aParms[1].setPointer(pvBuf, cbBuf); 1008 svcTable.pfnHostCall(svcTable.pvService, G ET_PROP_HOST, RT_ELEMENTS(aParms), aParms);1008 svcTable.pfnHostCall(svcTable.pvService, GUEST_PROP_FN_GET_PROP_HOST, RT_ELEMENTS(aParms), aParms); 1009 1009 1010 1010 RTTestGuardedFree(g_hTest, pvBuf); … … 1042 1042 aParms[0].setString("*"); 1043 1043 aParms[1].setPointer(pvBuf, cbBuf); 1044 svcTable.pfnHostCall(svcTable.pvService, ENUM_PROPS_HOST, RT_ELEMENTS(aParms), aParms);1044 svcTable.pfnHostCall(svcTable.pvService, GUEST_PROP_FN_ENUM_PROPS_HOST, RT_ELEMENTS(aParms), aParms); 1045 1045 1046 1046 RTTestGuardedFree(g_hTest, pvBuf); … … 1111 1111 aParms[0].setPointer(szProp, (uint32_t)cchProp + 1); 1112 1112 aParms[1].setPointer(szBuffer, sizeof(szBuffer)); 1113 RTTESTI_CHECK_RC_BREAK(svcTable.pfnHostCall(svcTable.pvService, G ET_PROP_HOST, 4, aParms), VINF_SUCCESS);1113 RTTESTI_CHECK_RC_BREAK(svcTable.pfnHostCall(svcTable.pvService, GUEST_PROP_FN_GET_PROP_HOST, 4, aParms), VINF_SUCCESS); 1114 1114 } 1115 1115 cNsElapsed = RTTimeNanoTS() - cNsElapsed; -
trunk/src/VBox/Main/src-client/ConsoleImpl.cpp
r70036 r70058 1766 1766 * changes to the object state. 1767 1767 */ 1768 P HOSTCALLBACKDATA pCBData = reinterpret_cast<PHOSTCALLBACKDATA>(pvParms);1769 AssertReturn(sizeof( HOSTCALLBACKDATA) == cbParms, VERR_INVALID_PARAMETER);1770 AssertReturn( HOSTCALLBACKMAGIC == pCBData->u32Magic, VERR_INVALID_PARAMETER);1768 PGUESTPROPHOSTCALLBACKDATA pCBData = reinterpret_cast<PGUESTPROPHOSTCALLBACKDATA>(pvParms); 1769 AssertReturn(sizeof(GUESTPROPHOSTCALLBACKDATA) == cbParms, VERR_INVALID_PARAMETER); 1770 AssertReturn(pCBData->u32Magic == GUESTPROPHOSTCALLBACKDATA_MAGIC, VERR_INVALID_PARAMETER); 1771 1771 LogFlow(("Console::doGuestPropNotification: pCBData={.pcszName=%s, .pcszValue=%s, .pcszFlags=%s}\n", 1772 1772 pCBData->pcszName, pCBData->pcszValue, pCBData->pcszFlags)); … … 1839 1839 parm[2].u.uint32 = 0; 1840 1840 1841 vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", ENUM_PROPS_HOST, 3, 1842 &parm[0]); 1841 vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_ENUM_PROPS_HOST, 3, &parm[0]); 1843 1842 Utf8Buf.jolt(); 1844 1843 if (parm[2].type != VBOX_HGCM_SVC_PARM_32BIT) … … 5941 5940 { 5942 5941 VBOXHGCMSVCPARM parm[4]; 5943 char szBuffer[ MAX_VALUE_LEN +MAX_FLAGS_LEN];5942 char szBuffer[GUEST_PROP_MAX_VALUE_LEN + GUEST_PROP_MAX_FLAGS_LEN]; 5944 5943 5945 5944 parm[0].type = VBOX_HGCM_SVC_PARM_PTR; … … 5957 5956 parm[3].u.uint32 = 0; 5958 5957 5959 int vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", G ET_PROP_HOST,5958 int vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_GET_PROP_HOST, 5960 5959 4, &parm[0]); 5961 5960 /* The returned string should never be able to be greater than our buffer */ … … 6028 6027 if (aFlags.isEmpty()) 6029 6028 { 6030 vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", SET_PROP_VALUE_HOST, 6031 2, &parm[0]); 6029 vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_SET_PROP_VALUE_HOST, 2, &parm[0]); 6032 6030 } 6033 6031 else … … 6037 6035 parm[2].u.pointer.size = (uint32_t)aFlags.length() + 1; /* The + 1 is the null terminator */ 6038 6036 6039 vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", SET_PROP_HOST, 6040 3, &parm[0]); 6037 vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_SET_PROP_HOST, 3, &parm[0]); 6041 6038 } 6042 6039 … … 6073 6070 parm[0].u.pointer.size = (uint32_t)aName.length() + 1; /* The + 1 is the null terminator */ 6074 6071 6075 int vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", DEL_PROP_HOST, 6076 1, &parm[0]); 6072 int vrc = m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_DEL_PROP_HOST, 1, &parm[0]); 6077 6073 6078 6074 HRESULT hrc = S_OK; -
trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp
r70035 r70058 5906 5906 5907 5907 #ifdef VBOX_WITH_GUEST_PROPS 5908 5908 5909 /** 5909 5910 * Set an array of guest properties … … 5930 5931 parms[3].u.pointer.size = 0; /* We don't actually care. */ 5931 5932 5932 pVMMDev->hgcmHostCall("VBoxGuestPropSvc", 5933 guestProp::SET_PROPS_HOST, 5934 4, 5935 &parms[0]); 5933 pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_SET_PROPS_HOST, 4, &parms[0]); 5936 5934 } 5937 5935 … … 5958 5956 parms[2].u.pointer.addr = (void *)pszFlags; 5959 5957 parms[2].u.pointer.size = (uint32_t)strlen(pszFlags) + 1; 5960 pVMMDev->hgcmHostCall("VBoxGuestPropSvc", guestProp::SET_PROP_HOST, 3, 5961 &parms[0]); 5958 pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_SET_PROP_HOST, 3, &parms[0]); 5962 5959 } 5963 5960 … … 5969 5966 * @param eFlags the flags to set 5970 5967 */ 5971 int configSetGlobalPropertyFlags(VMMDev * const pVMMDev, 5972 guestProp::ePropFlags eFlags) 5968 int configSetGlobalPropertyFlags(VMMDev * const pVMMDev, uint32_t fFlags) 5973 5969 { 5974 5970 VBOXHGCMSVCPARM paParm; 5975 paParm.setUInt32(eFlags); 5976 int rc = pVMMDev->hgcmHostCall("VBoxGuestPropSvc", 5977 guestProp::SET_GLOBAL_FLAGS_HOST, 1, 5978 &paParm); 5971 paParm.setUInt32(fFlags); 5972 int rc = pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_SET_GLOBAL_FLAGS_HOST, 1, &paParm); 5979 5973 if (RT_FAILURE(rc)) 5980 5974 { 5981 char szFlags[ guestProp::MAX_FLAGS_LEN];5982 if (RT_FAILURE( writeFlags(eFlags, szFlags)))5975 char szFlags[GUEST_PROP_MAX_FLAGS_LEN]; 5976 if (RT_FAILURE(GuestPropWriteFlags(fFlags, szFlags))) 5983 5977 Log(("Failed to set the global flags.\n")); 5984 5978 else … … 5987 5981 return rc; 5988 5982 } 5983 5989 5984 #endif /* VBOX_WITH_GUEST_PROPS */ 5990 5985 … … 6020 6015 { 6021 6016 VBOXHGCMSVCPARM Params[2]; 6022 int rc2 = pConsole->m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", guestProp::GET_DBGF_INFO_FN, 2, &Params[0]);6017 int rc2 = pConsole->m_pVMMDev->hgcmHostCall("VBoxGuestPropSvc", GUEST_PROP_FN_GET_DBGF_INFO_FN, 2, &Params[0]); 6023 6018 if (RT_SUCCESS(rc2)) 6024 6019 { … … 6134 6129 6135 6130 #ifdef VBOX_WITH_GUEST_PROPS_RDONLY_GUEST 6136 rc = configSetGlobalPropertyFlags(pConsole->m_pVMMDev, 6137 guestProp::RDONLYGUEST); 6131 rc = configSetGlobalPropertyFlags(pConsole->m_pVMMDev, guestProp::RDONLYGUEST); 6138 6132 AssertRCReturn(rc, rc); 6139 6133 #endif -
trunk/src/VBox/Main/src-server/MachineImpl.cpp
r68986 r70058 5654 5654 if (it != mHWData->mGuestProperties.end()) 5655 5655 { 5656 char szFlags[ MAX_FLAGS_LEN + 1];5656 char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1]; 5657 5657 aValue = it->second.strValue; 5658 5658 *aTimestamp = it->second.mTimestamp; 5659 writeFlags(it->second.mFlags, szFlags);5659 GuestPropWriteFlags(it->second.mFlags, szFlags); 5660 5660 aFlags = Utf8Str(szFlags); 5661 5661 } … … 5752 5752 try 5753 5753 { 5754 uint32_t fFlags = NILFLAG;5755 if (aFlags.length() && RT_FAILURE( validateFlags(aFlags.c_str(), &fFlags)))5754 uint32_t fFlags = GUEST_PROP_F_NILFLAG; 5755 if (aFlags.length() && RT_FAILURE(GuestPropValidateFlags(aFlags.c_str(), &fFlags))) 5756 5756 return setError(E_INVALIDARG, tr("Invalid guest property flag values: '%s'"), aFlags.c_str()); 5757 5757 … … 5774 5774 else 5775 5775 { 5776 if (it->second.mFlags & ( RDONLYHOST))5776 if (it->second.mFlags & (GUEST_PROP_F_RDONLYHOST)) 5777 5777 { 5778 5778 rc = setError(E_ACCESSDENIED, tr("The property '%s' cannot be changed by the host"), aName.c_str()); … … 5936 5936 aFlags.resize(cEntries); 5937 5937 5938 char szFlags[ MAX_FLAGS_LEN + 1];5938 char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1]; 5939 5939 size_t i = 0; 5940 5940 for (HWData::GuestPropertyMap::const_iterator … … 5946 5946 aValues[i] = it->second.strValue; 5947 5947 aTimestamps[i] = it->second.mTimestamp; 5948 writeFlags(it->second.mFlags, szFlags);5948 GuestPropWriteFlags(it->second.mFlags, szFlags); 5949 5949 aFlags[i] = Utf8Str(szFlags); 5950 5950 } … … 9158 9158 { 9159 9159 const settings::GuestProperty &prop = *it; 9160 uint32_t fFlags = guestProp::NILFLAG;9161 guestProp::validateFlags(prop.strFlags.c_str(), &fFlags);9160 uint32_t fFlags = GUEST_PROP_F_NILFLAG; 9161 GuestPropValidateFlags(prop.strFlags.c_str(), &fFlags); 9162 9162 if ( fSkipTransientGuestProperties 9163 && ( fFlags & guestProp::TRANSIENT9164 || fFlags & guestProp::TRANSRESET))9163 && ( fFlags & GUEST_PROP_F_TRANSIENT 9164 || fFlags & GUEST_PROP_F_TRANSRESET)) 9165 9165 { 9166 9166 it = llGuestProperties.erase(it); … … 10454 10454 || mData->mMachineState == MachineState_Aborted 10455 10455 || mData->mMachineState == MachineState_Teleported) 10456 && ( property.mFlags & guestProp::TRANSIENT 10457 || property.mFlags & guestProp::TRANSRESET)) 10456 && (property.mFlags & (GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_TRANSRESET))) 10458 10457 continue; 10459 settings::GuestProperty prop; 10458 settings::GuestProperty prop; /// @todo r=bird: some excellent variable name choices here: 'prop' and 'property'; No 'const' clue either. 10460 10459 prop.strName = it->first; 10461 10460 prop.strValue = property.strValue; 10462 10461 prop.timestamp = property.mTimestamp; 10463 char szFlags[ guestProp::MAX_FLAGS_LEN + 1];10464 guestProp::writeFlags(property.mFlags, szFlags);10462 char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1]; 10463 GuestPropWriteFlags(property.mFlags, szFlags); 10465 10464 prop.strFlags = szFlags; 10466 10465 … … 13541 13540 ++it, ++i) 13542 13541 { 13543 char szFlags[ MAX_FLAGS_LEN + 1];13542 char szFlags[GUEST_PROP_MAX_FLAGS_LEN + 1]; 13544 13543 aNames[i] = it->first; 13545 13544 aValues[i] = it->second.strValue; … … 13549 13548 if (it->second.mFlags) 13550 13549 { 13551 writeFlags(it->second.mFlags, szFlags);13550 GuestPropWriteFlags(it->second.mFlags, szFlags); 13552 13551 aFlags[i] = szFlags; 13553 13552 } … … 13576 13575 * Convert input up front. 13577 13576 */ 13578 uint32_t fFlags = NILFLAG;13577 uint32_t fFlags = GUEST_PROP_F_NILFLAG; 13579 13578 if (aFlags.length()) 13580 13579 { 13581 int vrc = validateFlags(aFlags.c_str(), &fFlags);13580 int vrc = GuestPropValidateFlags(aFlags.c_str(), &fFlags); 13582 13581 AssertRCReturn(vrc, E_INVALIDARG); 13583 13582 } … … 14803 14802 { 14804 14803 uint32_t fFlags = it->second.mFlags; 14805 if ( fFlags & guestProp::TRANSIENT 14806 || fFlags & guestProp::TRANSRESET) 14804 if (fFlags & (GUEST_PROP_F_TRANSIENT | GUEST_PROP_F_TRANSRESET)) 14807 14805 { 14808 14806 /* iterator where we need to continue after the erase call
Note:
See TracChangeset
for help on using the changeset viewer.
