void ParsedRegexpFilter_base::parse (const Bstr &aFilter)
{
/// @todo (dmik) parse "rx:<regexp>" string
// note, that min/max checks must not be done, when the string
// begins with "rx:". These limits are for exact matching only!
// empty or null string means any match (see #isMatch() below),
// so we don't apply Min/Max restrictions in this case
if (!aFilter.isEmpty())
{
size_t len = aFilter.length();
if (mMinLen > 0 && len < mMinLen)
{
mNull = mValid = false;
mErrorPosition = len;
return;
}
if (mMaxLen > 0 && len > mMaxLen)
{
mNull = mValid = false;
mErrorPosition = mMaxLen;
return;
}
}
mSimple = aFilter;
mNull = false;
mValid = true;
mErrorPosition = 0;
}
/**
* Initializes itself by fetching error information from the given error info
* object.
*/
HRESULT VirtualBoxErrorInfo::init(IErrorInfo *aInfo)
{
AssertReturn(aInfo, E_FAIL);
HRESULT rc = S_OK;
/* We don't return a failure if talking to IErrorInfo fails below to
* protect ourselves from bad IErrorInfo implementations (the
* corresponding fields will simply remain null in this case). */
m_resultCode = S_OK;
m_resultDetail = 0;
rc = aInfo->GetGUID(m_IID.asOutParam());
AssertComRC(rc);
Bstr bstrComponent;
rc = aInfo->GetSource(bstrComponent.asOutParam());
AssertComRC(rc);
m_strComponent = bstrComponent;
Bstr bstrText;
rc = aInfo->GetDescription(bstrText.asOutParam());
AssertComRC(rc);
m_strText = bstrText;
return S_OK;
}
STDMETHODIMP VRDEServer::COMGETTER(AuthLibrary) (BSTR *aLibrary)
{
CheckComArgOutPointerValid(aLibrary);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
Bstr bstrLibrary;
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
bstrLibrary = mData->mAuthLibrary;
alock.release();
if (bstrLibrary.isEmpty())
{
/* Get the global setting. */
ComPtr<ISystemProperties> systemProperties;
HRESULT hrc = mParent->getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
if (SUCCEEDED(hrc))
hrc = systemProperties->COMGETTER(VRDEAuthLibrary)(bstrLibrary.asOutParam());
if (FAILED(hrc))
return setError(hrc, "failed to query the library setting\n");
}
bstrLibrary.cloneTo(aLibrary);
return S_OK;
}
bool
SITree::modify(const char* _str, unsigned _len, int _val)
{
if (_str == NULL || _len == 0)
{
printf("error in SITree-modify: empty string\n");
return false;
}
this->CopyToTransfer(_str, _len, 1);
this->request = 0;
const Bstr* _key = &transfer[1];
Bstr bstr = *_key;
int store;
SINode* ret = this->find(_key, &store, true);
if (ret == NULL || store == -1 || bstr != *(ret->getKey(store))) //tree is empty or not found
{
bstr.clear();
return false;
}
ret->setValue(_val, store);
ret->setDirty();
this->TSM->request(request);
bstr.clear();
return true;
}
//this function is useful for search and modify, and range-query
SINode* //return the first key's position that >= *_key
SITree::find(const Bstr* _key, int* _store, bool ifmodify)
{ //to assign value for this->bstr, function shouldn't be const!
if (this->root == NULL)
return NULL; //SITree Is Empty
SINode* p = root;
int i, j;
Bstr bstr = *_key; //local Bstr: multiple delete
while (!p->isLeaf())
{
if (ifmodify)
p->setDirty();
//j = p->getNum();
//for(i = 0; i < j; ++i) //BETTER(Binary-Search)
//if(bstr < *(p->getKey(i)))
//break;
i = p->searchKey_less(bstr);
p = p->getChild(i);
this->prepare(p);
}
j = p->getNum();
//for(i = 0; i < j; ++i)
//if(bstr <= *(p->getKey(i)))
//break;
i = p->searchKey_lessEqual(bstr);
if (i == j)
*_store = -1; //Not Found
else
*_store = i;
bstr.clear();
return p;
}
STDMETHODIMP GuestFileEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
{
switch (aType)
{
case VBoxEventType_OnGuestFileStateChanged:
{
HRESULT rc;
do
{
ComPtr<IGuestFileStateChangedEvent> pEvent = aEvent;
Assert(!pEvent.isNull());
ComPtr<IGuestFile> pProcess;
CHECK_ERROR_BREAK(pEvent, COMGETTER(File)(pProcess.asOutParam()));
AssertBreak(!pProcess.isNull());
FileStatus_T fileSts;
CHECK_ERROR_BREAK(pEvent, COMGETTER(Status)(&fileSts));
Bstr strPath;
CHECK_ERROR_BREAK(pProcess, COMGETTER(FileName)(strPath.asOutParam()));
ULONG uID;
CHECK_ERROR_BREAK(pProcess, COMGETTER(Id)(&uID));
RTPrintf("File ID=%RU32 \"%s\" changed status to [%s]\n",
uID, Utf8Str(strPath).c_str(), gctlFileStatusToText(fileSts));
} while (0);
break;
}
default:
AssertFailed();
}
return S_OK;
}
bool
SITree::search(const char* _str, unsigned _len, int* _val)
{
if (_str == NULL || _len == 0)
{
printf("error in SITree-search: empty string\n");
*_val = -1;
return false;
}
this->CopyToTransfer(_str, _len, 1);
request = 0;
Bstr bstr = this->transfer[1]; //not to modify its memory
int store;
SINode* ret = this->find(&transfer[1], &store, false);
if (ret == NULL || store == -1 || bstr != *(ret->getKey(store))) //tree is empty or not found
{
bstr.clear();
return false;
}
*_val = ret->getValue(store);
this->TSM->request(request);
bstr.clear();
return true;
}
/**
* Helper function used with "VBoxManage snapshot ... dump". Called from DumpSnapshot()
* for each hard disk attachment found in a virtual machine. This then writes out the
* root (base) medium for that hard disk attachment and recurses into the children
* tree of that medium, correlating it with the snapshots of the machine.
* @param pCurrentStateMedium constant, the medium listed in the current machine data (latest diff image).
* @param pMedium variant, initially the base medium, then a child of the base medium when recursing.
* @param pRootSnapshot constant, the root snapshot of the machine, if any; this then looks into the child snapshots.
* @param pCurrentSnapshot constant, the machine's current snapshot (so we can mark it in the output).
* @param uLevel variant, the recursion level for output indentation.
*/
void DumpMediumWithChildren(ComPtr<IMedium> &pCurrentStateMedium,
ComPtr<IMedium> &pMedium,
ComPtr<ISnapshot> &pRootSnapshot,
ComPtr<ISnapshot> &pCurrentSnapshot,
uint32_t uLevel)
{
HRESULT rc;
do
{
// print this medium
Bstr bstrMediumName;
CHECK_ERROR_BREAK(pMedium, COMGETTER(Name)(bstrMediumName.asOutParam()));
RTPrintf("%*s \"%ls\"%s\n",
uLevel * 2, "", // indent
bstrMediumName.raw(),
(pCurrentStateMedium == pMedium) ? " (CURSTATE)" : "");
// find and print the snapshot that uses this particular medium (diff image)
FindAndPrintSnapshotUsingMedium(pMedium, pRootSnapshot, pCurrentSnapshot, uLevel, 0);
// recurse into children
SafeIfaceArray<IMedium> aChildren;
CHECK_ERROR_BREAK(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(aChildren)));
for (uint32_t i = 0;
i < aChildren.size();
++i)
{
ComPtr<IMedium> pChild(aChildren[i]);
DumpMediumWithChildren(pCurrentStateMedium, pChild, pRootSnapshot, pCurrentSnapshot, uLevel + 1);
}
} while (0);
}
/**
* @interface_method_impl{PDMIPCIRAWUP,pfnPciDeviceConstructComplete}
*/
DECLCALLBACK(int) PCIRawDev::drvDeviceConstructComplete(PPDMIPCIRAWCONNECTOR pInterface, const char *pcszName,
uint32_t uHostPCIAddress, uint32_t uGuestPCIAddress,
int rc)
{
PDRVMAINPCIRAWDEV pThis = RT_FROM_CPP_MEMBER(pInterface, DRVMAINPCIRAWDEV, IConnector);
Console *pConsole = pThis->pPCIRawDev->getParent();
const ComPtr<IMachine>& machine = pConsole->machine();
ComPtr<IVirtualBox> vbox;
HRESULT hrc = machine->COMGETTER(Parent)(vbox.asOutParam());
Assert(SUCCEEDED(hrc));
ComPtr<IEventSource> es;
hrc = vbox->COMGETTER(EventSource)(es.asOutParam());
Assert(SUCCEEDED(hrc));
Bstr bstrId;
hrc = machine->COMGETTER(Id)(bstrId.asOutParam());
Assert(SUCCEEDED(hrc));
ComObjPtr<PCIDeviceAttachment> pda;
BstrFmt bstrName(pcszName);
pda.createObject();
pda->init(machine, bstrName, uHostPCIAddress, uGuestPCIAddress, TRUE);
Bstr msg("");
if (RT_FAILURE(rc))
msg = BstrFmt("runtime error %Rrc", rc);
fireHostPCIDevicePlugEvent(es, bstrId.raw(), true /* plugged */, RT_SUCCESS(rc) /* success */, pda, msg.raw());
return VINF_SUCCESS;
}
HRESULT VRDEServer::getAuthLibrary(com::Utf8Str &aLibrary)
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
aLibrary = mData->mAuthLibrary;
alock.release();
if (aLibrary.isEmpty())
{
/* Get the global setting. */
ComPtr<ISystemProperties> systemProperties;
HRESULT hrc = mParent->i_getVirtualBox()->COMGETTER(SystemProperties)(systemProperties.asOutParam());
if (SUCCEEDED(hrc))
{
Bstr strlib;
hrc = systemProperties->COMGETTER(VRDEAuthLibrary)(strlib.asOutParam());
if (SUCCEEDED(hrc))
aLibrary = Utf8Str(strlib).c_str();
}
if (FAILED(hrc))
return setError(hrc, "failed to query the library setting\n");
}
return S_OK;
}
static RTEXITCODE handleCreate(HandlerArg *a)
{
/*
* Parse input.
*/
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, a->argc, a->argv, NULL, 0, 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
int ch = RTGetOpt(&GetState, &ValueUnion);
if (ch != 0)
return errorGetOpt(USAGE_HOSTONLYIFS, ch, &ValueUnion);
/*
* Do the work.
*/
ComPtr<IHost> host;
CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE);
ComPtr<IHostNetworkInterface> hif;
ComPtr<IProgress> progress;
CHECK_ERROR2I_RET(host, CreateHostOnlyNetworkInterface(hif.asOutParam(), progress.asOutParam()), RTEXITCODE_FAILURE);
/*HRESULT hrc =*/ showProgress(progress);
CHECK_PROGRESS_ERROR_RET(progress, ("Failed to create the host-only adapter"), RTEXITCODE_FAILURE);
Bstr bstrName;
CHECK_ERROR2I(hif, COMGETTER(Name)(bstrName.asOutParam()));
RTPrintf("Interface '%ls' was successfully created\n", bstrName.raw());
return RTEXITCODE_SUCCESS;
}
static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
ComSafeArrayIn(IPerformanceMetric*, aMetrics))
{
HRESULT rc;
com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
if (metrics.size())
{
ComPtr<IUnknown> object;
Bstr metricName;
RTPrintf("The following metrics were modified:\n\n"
"Object Metric\n"
"---------- --------------------\n");
for (size_t i = 0; i < metrics.size(); i++)
{
CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam()));
CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam()));
RTPrintf("%-10ls %-20ls\n",
getObjectName(aVirtualBox, object).raw(), metricName.raw());
}
RTPrintf("\n");
}
else
{
RTMsgError("No metrics match the specified filter!");
}
}
static int NetIfAdpCtl(HostNetworkInterface * pIf, const char *pszAddr, const char *pszOption, const char *pszMask)
{
Bstr interfaceName;
pIf->COMGETTER(Name)(interfaceName.asOutParam());
Utf8Str strName(interfaceName);
return NetIfAdpCtl(strName.c_str(), pszAddr, pszOption, pszMask);
}
/**
* List media information.
*
* @returns See produceList.
* @param pVirtualBox Reference to the IVirtualBox smart pointer.
* @param aMedia Medium objects to list information for.
* @param pszParentUUIDStr String with the parent UUID string (or "base").
* @param fOptLong Long (@c true) or short list format.
*/
static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox,
const com::SafeIfaceArray<IMedium> &aMedia,
const char *pszParentUUIDStr,
bool fOptLong)
{
HRESULT rc = S_OK;
for (size_t i = 0; i < aMedia.size(); ++i)
{
ComPtr<IMedium> pMedium = aMedia[i];
rc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
RTPrintf("\n");
com::SafeIfaceArray<IMedium> children;
CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
if (children.size() > 0)
{
Bstr uuid;
pMedium->COMGETTER(Id)(uuid.asOutParam());
// depth first listing of child media
rc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
}
}
return rc;
}
/**
* Determines the maximum balloon size to set for the specified machine.
*
* @return unsigned long Balloon size (in MB) to set, 0 if no ballooning required.
* @param rptrMachine Pointer to interface of specified machine.
*/
static unsigned long balloonGetMaxSize(const ComPtr<IMachine> &rptrMachine)
{
/*
* Try to retrieve the balloon maximum size via the following order:
* - command line parameter ("--balloon-max")
* Legacy (VBoxBalloonCtrl):
* - per-VM parameter ("VBoxInternal/Guest/BalloonSizeMax")
* Global:
* - global parameter ("VBoxInternal/Guest/BalloonSizeMax")
* New:
* - per-VM parameter ("VBoxInternal2/Watchdog/BalloonCtrl/BalloonSizeMax")
*
* By default (e.g. if none of above is set), ballooning is disabled.
*/
unsigned long ulBalloonMax = g_ulMemoryBalloonMaxMB;
if (!ulBalloonMax)
{
int vrc = cfgGetValueULong(g_pVirtualBox, rptrMachine,
"VBoxInternal/Guest/BalloonSizeMax", "VBoxInternal/Guest/BalloonSizeMax", &ulBalloonMax, 0 /* Ballooning disabled */);
if (RT_FAILURE(vrc))
{
/* Try (new) VBoxWatch per-VM approach. */
Bstr strValue;
HRESULT rc = rptrMachine->GetExtraData(Bstr("VBoxInternal2/Watchdog/BalloonCtrl/BalloonSizeMax").raw(),
strValue.asOutParam());
if ( SUCCEEDED(rc)
&& !strValue.isEmpty())
{
ulBalloonMax = Utf8Str(strValue).toUInt32();
}
}
}
return ulBalloonMax;
}
STDMETHODIMP VirtualBoxErrorInfo::GetGUID (GUID *guid)
{
Bstr iid;
HRESULT rc = COMGETTER(InterfaceID) (iid.asOutParam());
if (SUCCEEDED(rc))
*guid = Guid(iid).ref();
return rc;
}
void ErrorInfo::init(IVirtualBoxErrorInfo *info)
{
AssertReturnVoid(info);
HRESULT rc = E_FAIL;
bool gotSomething = false;
bool gotAll = true;
LONG lrc, lrd;
rc = info->COMGETTER(ResultCode)(&lrc); mResultCode = lrc;
gotSomething |= SUCCEEDED(rc);
gotAll &= SUCCEEDED(rc);
rc = info->COMGETTER(ResultDetail)(&lrd); mResultDetail = lrd;
gotSomething |= SUCCEEDED(rc);
gotAll &= SUCCEEDED(rc);
Bstr iid;
rc = info->COMGETTER(InterfaceID)(iid.asOutParam());
gotSomething |= SUCCEEDED(rc);
gotAll &= SUCCEEDED(rc);
if (SUCCEEDED(rc))
{
mInterfaceID = iid;
GetInterfaceNameByIID(mInterfaceID.ref(), mInterfaceName.asOutParam());
}
rc = info->COMGETTER(Component)(mComponent.asOutParam());
gotSomething |= SUCCEEDED(rc);
gotAll &= SUCCEEDED(rc);
rc = info->COMGETTER(Text)(mText.asOutParam());
gotSomething |= SUCCEEDED(rc);
gotAll &= SUCCEEDED(rc);
m_pNext = NULL;
ComPtr<IVirtualBoxErrorInfo> next;
rc = info->COMGETTER(Next)(next.asOutParam());
if (SUCCEEDED(rc) && !next.isNull())
{
m_pNext = new ErrorInfo(next);
Assert(m_pNext != NULL);
if (!m_pNext)
rc = E_OUTOFMEMORY;
}
gotSomething |= SUCCEEDED(rc);
gotAll &= SUCCEEDED(rc);
mIsBasicAvailable = gotSomething;
mIsFullAvailable = gotAll;
mErrorInfo = info;
AssertMsg(gotSomething, ("Nothing to fetch!\n"));
}
HRESULT HostNetworkInterface::i_setVirtualBox(VirtualBox *pVirtualBox)
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AssertReturn(mVirtualBox != pVirtualBox, S_OK);
unconst(mVirtualBox) = pVirtualBox;
#if !defined(RT_OS_WINDOWS)
/* If IPv4 address hasn't been initialized */
if (m.IPAddress == 0 && mIfType == HostNetworkInterfaceType_HostOnly)
{
Bstr tmpAddr, tmpMask;
HRESULT hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPAddress",
mInterfaceName.c_str()).raw(),
tmpAddr.asOutParam());
if (FAILED(hrc) || tmpAddr.isEmpty())
tmpAddr = getDefaultIPv4Address(mInterfaceName);
hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPNetMask",
mInterfaceName.c_str()).raw(),
tmpMask.asOutParam());
if (FAILED(hrc) || tmpMask.isEmpty())
tmpMask = Bstr(VBOXNET_IPV4MASK_DEFAULT);
m.IPAddress = inet_addr(Utf8Str(tmpAddr).c_str());
m.networkMask = inet_addr(Utf8Str(tmpMask).c_str());
}
if (m.IPV6Address.isEmpty())
{
Bstr bstrIPV4Addr;
Bstr tmpPrefixLen;
HRESULT hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6Address",
mInterfaceName.c_str()).raw(),
bstrIPV4Addr.asOutParam());
if (SUCCEEDED(hrc))
{
m.IPV6Address = bstrIPV4Addr;
if (!m.IPV6Address.isEmpty())
{
hrc = mVirtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6PrefixLen",
mInterfaceName.c_str()).raw(),
tmpPrefixLen.asOutParam());
if (SUCCEEDED(hrc) && !tmpPrefixLen.isEmpty())
m.IPV6NetworkMaskPrefixLength = Utf8Str(tmpPrefixLen).toUInt32();
else
m.IPV6NetworkMaskPrefixLength = 64;
}
}
}
#endif
return S_OK;
}
static int vmListBuild()
{
serviceLogVerbose(("Building VM list ...\n"));
int rc = RTCritSectEnter(&g_csMachines);
if (RT_SUCCESS(rc))
{
/*
* Make sure the list is empty.
*/
g_mapVM.clear();
/*
* Get the list of all _running_ VMs
*/
com::SafeIfaceArray<IMachine> machines;
HRESULT hrc = g_pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
if (SUCCEEDED(hrc))
{
/*
* Iterate through the collection
*/
for (size_t i = 0; i < machines.size(); ++i)
{
if (machines[i])
{
Bstr strUUID;
CHECK_ERROR_BREAK(machines[i], COMGETTER(Id)(strUUID.asOutParam()));
BOOL fAccessible;
CHECK_ERROR_BREAK(machines[i], COMGETTER(Accessible)(&fAccessible));
if (!fAccessible)
{
serviceLogVerbose(("Machine \"%ls\" is inaccessible, skipping\n",
strUUID.raw()));
continue;
}
rc = machineAdd(strUUID);
if (RT_FAILURE(rc))
break;
}
}
if (!machines.size())
serviceLogVerbose(("No machines to add found at the moment!\n"));
}
int rc2 = RTCritSectLeave(&g_csMachines);
if (RT_SUCCESS(rc))
rc = rc2;
}
return rc;
}
STDMETHODIMP Guest::COMGETTER(AdditionsVersion)(BSTR *a_pbstrAdditionsVersion)
{
CheckComArgOutPointerValid(a_pbstrAdditionsVersion);
AutoCaller autoCaller(this);
HRESULT hrc = autoCaller.rc();
if (SUCCEEDED(hrc))
{
AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
/*
* Return the ReportGuestInfo2 version info if available.
*/
if ( !mData.mAdditionsVersionNew.isEmpty()
|| mData.mAdditionsRunLevel <= AdditionsRunLevelType_None)
mData.mAdditionsVersionNew.cloneTo(a_pbstrAdditionsVersion);
else
{
/*
* If we're running older guest additions (< 3.2.0) try get it from
* the guest properties. Detected switched around Version and
* Revision in early 3.1.x releases (see r57115).
*/
ComPtr<IMachine> ptrMachine = mParent->machine();
alock.release(); /* No need to hold this during the IPC fun. */
Bstr bstr;
hrc = ptrMachine->GetGuestPropertyValue(Bstr("/VirtualBox/GuestAdd/Version").raw(), bstr.asOutParam());
if ( SUCCEEDED(hrc)
&& !bstr.isEmpty())
{
Utf8Str str(bstr);
if (str.count('.') == 0)
hrc = ptrMachine->GetGuestPropertyValue(Bstr("/VirtualBox/GuestAdd/Revision").raw(), bstr.asOutParam());
str = bstr;
if (str.count('.') != 2)
hrc = E_FAIL;
}
if (SUCCEEDED(hrc))
bstr.detachTo(a_pbstrAdditionsVersion);
else
{
/* Returning 1.4 is better than nothing. */
alock.acquire();
mData.mInterfaceVersion.cloneTo(a_pbstrAdditionsVersion);
hrc = S_OK;
}
}
}
return hrc;
}
/**
* List host information.
*
* @returns See produceList.
* @param pVirtualBox Reference to the IVirtualBox smart pointer.
*/
static HRESULT listHostInfo(const ComPtr<IVirtualBox> pVirtualBox)
{
HRESULT rc;
ComPtr<IHost> Host;
CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
RTPrintf("Host Information:\n\n");
LONG64 u64UtcTime = 0;
CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime));
RTTIMESPEC timeSpec;
char szTime[32];
RTPrintf("Host time: %s\n", RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
ULONG processorOnlineCount = 0;
CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
RTPrintf("Processor online count: %lu\n", processorOnlineCount);
ULONG processorCount = 0;
CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
RTPrintf("Processor count: %lu\n", processorCount);
ULONG processorOnlineCoreCount = 0;
CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount));
RTPrintf("Processor online core count: %lu\n", processorOnlineCoreCount);
ULONG processorCoreCount = 0;
CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount));
RTPrintf("Processor core count: %lu\n", processorCoreCount);
ULONG processorSpeed = 0;
Bstr processorDescription;
for (ULONG i = 0; i < processorCount; i++)
{
CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
if (processorSpeed)
RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed);
else
RTPrintf("Processor#%u speed: unknown\n", i);
CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
RTPrintf("Processor#%u description: %ls\n", i, processorDescription.raw());
}
ULONG memorySize = 0;
CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
RTPrintf("Memory size: %lu MByte\n", memorySize);
ULONG memoryAvailable = 0;
CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
RTPrintf("Memory available: %lu MByte\n", memoryAvailable);
Bstr operatingSystem;
CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
RTPrintf("Operating system: %ls\n", operatingSystem.raw());
Bstr oSVersion;
CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
RTPrintf("Operating system version: %ls\n", oSVersion.raw());
return rc;
}
bool HostNetworkInterface::isInConfigFile(void)
{
/* We care about host-only adapters only */
if (mIfType != HostNetworkInterfaceType_HostOnly)
return true;
Assert(mVirtualBox != NULL);
if (mVirtualBox == NULL)
return false; /* Trigger config update, which will fail with proper return code */
Bstr tmpName;
mVirtualBox->GetExtraData(Bstr(Utf8StrFmt("HostOnly/{%RTuuid}/Name", mGuid)).raw(), tmpName.asOutParam());
return (tmpName.isNotEmpty() && tmpName == mInterfaceName);
}
/**
* Issued by the guest when a guest user changed its state.
*
* @return IPRT status code.
* @param aUser Guest user name.
* @param aDomain Domain of guest user account. Optional.
* @param enmState New state to indicate.
* @param pbDetails Pointer to state details. Optional.
* @param cbDetails Size (in bytes) of state details. Pass 0 if not used.
*/
void Guest::i_onUserStateChange(Bstr aUser, Bstr aDomain, VBoxGuestUserState enmState,
const uint8_t *pbDetails, uint32_t cbDetails)
{
LogFlowThisFunc(("\n"));
AutoCaller autoCaller(this);
AssertComRCReturnVoid(autoCaller.rc());
Bstr strDetails; /** @todo Implement state details here. */
fireGuestUserStateChangedEvent(mEventSource, aUser.raw(), aDomain.raw(),
(GuestUserState_T)enmState, strDetails.raw());
LogFlowFuncLeave();
}
static DECLCALLBACK(int) VBoxModAPIMonitorMain(void)
{
static uint64_t uLastRun = 0;
uint64_t uNow = RTTimeProgramMilliTS();
uint64_t uDelta = uNow - uLastRun;
if (uDelta < 1000) /* Only check every second (or later). */
return VINF_SUCCESS;
uLastRun = uNow;
int vrc = VINF_SUCCESS;
HRESULT rc;
#ifdef DEBUG
serviceLogVerbose(("apimon: Checking for API heartbeat (%RU64ms) ...\n",
g_ulAPIMonIslnTimeoutMS));
#endif
do
{
Bstr strHeartbeat;
CHECK_ERROR_BREAK(g_pVirtualBox, GetExtraData(Bstr("Watchdog/APIMonitor/Heartbeat").raw(),
strHeartbeat.asOutParam()));
if ( SUCCEEDED(rc)
&& !strHeartbeat.isEmpty()
&& g_strAPIMonIslnLastBeat.compare(strHeartbeat, Bstr::CaseSensitive))
{
serviceLogVerbose(("apimon: API heartbeat received, resetting timeout\n"));
g_uAPIMonIslnLastBeatMS = 0;
g_strAPIMonIslnLastBeat = strHeartbeat;
}
else
{
g_uAPIMonIslnLastBeatMS += uDelta;
if (g_uAPIMonIslnLastBeatMS > g_ulAPIMonIslnTimeoutMS)
{
serviceLogVerbose(("apimon: No API heartbeat within time received (%RU64ms)\n",
g_ulAPIMonIslnTimeoutMS));
vrc = apimonTrigger(g_enmAPIMonIslnResp);
g_uAPIMonIslnLastBeatMS = 0;
}
}
} while (0);
if (FAILED(rc))
vrc = VERR_COM_IPRT_ERROR;
return vrc;
}
int NetIfRemoveHostOnlyNetworkInterface(VirtualBox *pVirtualBox, IN_GUID aId,
IProgress **aProgress)
{
#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
/* create a progress object */
ComObjPtr<Progress> progress;
progress.createObject();
ComPtr<IHost> host;
int rc = VINF_SUCCESS;
HRESULT hr = pVirtualBox->COMGETTER(Host)(host.asOutParam());
if (SUCCEEDED(hr))
{
Bstr ifname;
ComPtr<IHostNetworkInterface> iface;
if (FAILED(host->FindHostNetworkInterfaceById(Guid(aId).toUtf16().raw(), iface.asOutParam())))
return VERR_INVALID_PARAMETER;
iface->COMGETTER(Name)(ifname.asOutParam());
if (ifname.isEmpty())
return VERR_INTERNAL_ERROR;
rc = progress->init(pVirtualBox, host,
Bstr("Removing host network interface").raw(),
FALSE /* aCancelable */);
if (SUCCEEDED(rc))
{
progress.queryInterfaceTo(aProgress);
rc = NetIfAdpCtl(Utf8Str(ifname).c_str(), "remove", NULL, NULL);
if (RT_FAILURE(rc))
progress->i_notifyComplete(E_FAIL,
COM_IIDOF(IHostNetworkInterface),
HostNetworkInterface::getStaticComponentName(),
"Failed to execute '" VBOXNETADPCTL_NAME "' (exit status: %d)", rc);
else
progress->i_notifyComplete(S_OK);
}
}
else
{
progress->i_notifyComplete(hr);
rc = VERR_INTERNAL_ERROR;
}
return rc;
#else
NOREF(pVirtualBox);
NOREF(aId);
NOREF(aProgress);
return VERR_NOT_IMPLEMENTED;
#endif
}
HRESULT MachineDebugger::logStringProps(PRTLOGGER pLogger, PFNLOGGETSTR pfnLogGetStr,
const char *pszLogGetStr, BSTR *a_pbstrSettings)
{
/* Make sure the VM is powered up. */
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
Console::SafeVMPtr ptrVM(mParent);
HRESULT hrc = ptrVM.rc();
if (FAILED(hrc))
return hrc;
/* Make sure we've got a logger. */
if (!pLogger)
{
Bstr bstrEmpty;
bstrEmpty.cloneTo(a_pbstrSettings);
return S_OK;
}
/* Do the job. */
size_t cbBuf = _1K;
for (;;)
{
char *pszBuf = (char *)RTMemTmpAlloc(cbBuf);
AssertReturn(pszBuf, E_OUTOFMEMORY);
int rc = pfnLogGetStr(pLogger, pszBuf, cbBuf);
if (RT_SUCCESS(rc))
{
try
{
Bstr bstrRet(pszBuf);
bstrRet.detachTo(a_pbstrSettings);
hrc = S_OK;
}
catch (std::bad_alloc)
{
hrc = E_OUTOFMEMORY;
}
RTMemTmpFree(pszBuf);
return hrc;
}
RTMemTmpFree(pszBuf);
AssertReturn(rc == VERR_BUFFER_OVERFLOW, setError(VBOX_E_IPRT_ERROR, tr("%s returned %Rrc"), pszLogGetStr, rc));
/* try again with a bigger buffer. */
cbBuf *= 2;
AssertReturn(cbBuf <= _256K, setError(E_FAIL, tr("%s returns too much data"), pszLogGetStr));
}
}
RTEXITCODE handleUSBDevSource(HandlerArg *a)
{
HRESULT rc = S_OK;
/* at least: 0: command, 1: source id */
if (a->argc < 2)
return errorSyntax(USAGE_USBDEVSOURCE, "Not enough parameters");
ComPtr<IHost> host;
if (!strcmp(a->argv[0], "add"))
{
Bstr strBackend;
Bstr strAddress;
if (a->argc != 6)
return errorSyntax(USAGE_USBDEVSOURCE, "Invalid number of parameters");
for (int i = 2; i < a->argc; i++)
{
if (!strcmp(a->argv[i], "--backend"))
{
i++;
strBackend = a->argv[i];
}
else if (!strcmp(a->argv[i], "--address"))
{
i++;
strAddress = a->argv[i];
}
else
return errorSyntax(USAGE_USBDEVSOURCE, "Parameter \"%s\" is invalid", a->argv[i]);
}
SafeArray<BSTR> usbSourcePropNames;
SafeArray<BSTR> usbSourcePropValues;
CHECK_ERROR_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE);
CHECK_ERROR_RET(host, AddUSBDeviceSource(strBackend.raw(), Bstr(a->argv[1]).raw(), strAddress.raw(),
ComSafeArrayAsInParam(usbSourcePropNames), ComSafeArrayAsInParam(usbSourcePropValues)),
RTEXITCODE_FAILURE);
}
else if (!strcmp(a->argv[0], "remove"))
{
CHECK_ERROR_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE);
CHECK_ERROR_RET(host, RemoveUSBDeviceSource(Bstr(a->argv[1]).raw()), RTEXITCODE_FAILURE);
}
return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
/**
* Sets the Guest Additions version information details.
* Gets called by vmmdevUpdateGuestInfo2.
*
* @param aAdditionsVersion
* @param aVersionName
*/
void Guest::setAdditionsInfo2(Bstr aAdditionsVersion, Bstr aVersionName, Bstr aRevision)
{
AutoCaller autoCaller(this);
AssertComRCReturnVoid(autoCaller.rc());
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (!aVersionName.isEmpty())
/*
* aVersionName could be "x.y.z_BETA1_FOOBAR", so append revision manually to
* become "x.y.z_BETA1_FOOBAR r12345".
*/
mData.mAdditionsVersion = BstrFmt("%ls r%ls", aVersionName.raw(), aRevision.raw());
else /* aAdditionsVersion is in x.y.zr12345 format. */
mData.mAdditionsVersion = aAdditionsVersion;
}
/**
* Sets the general Guest Additions information like
* API (interface) version and OS type. Gets called by
* vmmdevUpdateGuestInfo.
*
* @param aInterfaceVersion
* @param aOsType
*/
void Guest::setAdditionsInfo(Bstr aInterfaceVersion, VBOXOSTYPE aOsType)
{
AutoCaller autoCaller(this);
AssertComRCReturnVoid(autoCaller.rc());
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/*
* Note: The Guest Additions API (interface) version is deprecated
* and will not be used anymore! We might need it to at least report
* something as version number if *really* ancient Guest Additions are
* installed (without the guest version + revision properties having set).
*/
mData.mInterfaceVersion = aInterfaceVersion;
/*
* Older Additions rely on the Additions API version whether they
* are assumed to be active or not. Since newer Additions do report
* the Additions version *before* calling this function (by calling
* VMMDevReportGuestInfo2, VMMDevReportGuestStatus, VMMDevReportGuestInfo,
* in that order) we can tell apart old and new Additions here. Old
* Additions never would set VMMDevReportGuestInfo2 (which set mData.mAdditionsVersion)
* so they just rely on the aInterfaceVersion string (which gets set by
* VMMDevReportGuestInfo).
*
* So only mark the Additions as being active (run level = system) when we
* don't have the Additions version set.
*/
if (mData.mAdditionsVersion.isEmpty())
{
if (aInterfaceVersion.isEmpty())
mData.mAdditionsRunLevel = AdditionsRunLevelType_None;
else
{
mData.mAdditionsRunLevel = AdditionsRunLevelType_System;
/*
* To keep it compatible with the old Guest Additions behavior we need to set the
* "graphics" (feature) facility to active as soon as we got the Guest Additions
* interface version.
*/
facilityUpdate(VBoxGuestFacilityType_Graphics, VBoxGuestFacilityStatus_Active);
}
}
/*
* Older Additions didn't have this finer grained capability bit,
* so enable it by default. Newer Additions will not enable this here
* and use the setSupportedFeatures function instead.
*/
facilityUpdate(VBoxGuestFacilityType_Graphics, facilityIsActive(VBoxGuestFacilityType_VBoxGuestDriver) ?
VBoxGuestFacilityStatus_Active : VBoxGuestFacilityStatus_Inactive);
/*
* Note! There is a race going on between setting mAdditionsRunLevel and
* mSupportsGraphics here and disabling/enabling it later according to
* its real status when using new(er) Guest Additions.
*/
mData.mOSTypeId = Global::OSTypeId (aOsType);
}
void GluePrintErrorInfo(const com::ErrorInfo &info)
{
bool haveResultCode = false;
#if defined (RT_OS_WIN)
haveResultCode = info.isFullAvailable();
bool haveComponent = true;
bool haveInterfaceID = true;
#else /* defined (RT_OS_WIN) */
haveResultCode = true;
bool haveComponent = info.isFullAvailable();
bool haveInterfaceID = info.isFullAvailable();
#endif
Utf8Str str;
RTCList<Utf8Str> comp;
Bstr bstrDetailsText = info.getText();
if (!bstrDetailsText.isEmpty())
str = Utf8StrFmt("%ls\n",
bstrDetailsText.raw());
if (haveResultCode)
comp.append(Utf8StrFmt("code %Rhrc (0x%RX32)",
info.getResultCode(),
info.getResultCode()));
if (haveComponent)
comp.append(Utf8StrFmt("component %ls",
info.getComponent().raw()));
if (haveInterfaceID)
comp.append(Utf8StrFmt("interface %ls",
info.getInterfaceName().raw()));
if (!info.getCalleeName().isEmpty())
comp.append(Utf8StrFmt("callee %ls",
info.getCalleeName().raw()));
if (comp.size() > 0)
{
str += "Details: ";
for (size_t i = 0; i < comp.size() - 1; ++i)
str += comp.at(i) + ", ";
str += comp.last();
str += "\n";
}
// print and log
RTMsgError("%s", str.c_str());
Log(("ERROR: %s", str.c_str()));
}
