int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
{
int rc = VINF_SUCCESS;
size_t cbNeeded;
char *pBuf, *pNext;
int aiMib[6];
unsigned short u16DefaultIface = 0; /* shut up gcc. */
bool fDefaultIfaceExistent = true;
/* Get the index of the interface associated with default route. */
rc = getDefaultIfaceIndex(&u16DefaultIface, PF_INET);
if (RT_FAILURE(rc))
{
fDefaultIfaceExistent = false;
rc = VINF_SUCCESS;
}
aiMib[0] = CTL_NET;
aiMib[1] = PF_ROUTE;
aiMib[2] = 0;
aiMib[3] = 0; /* address family */
aiMib[4] = NET_RT_IFLIST;
aiMib[5] = 0;
if (sysctl(aiMib, 6, NULL, &cbNeeded, NULL, 0) < 0)
{
Log(("NetIfList: Failed to get estimate for list size (errno=%d).\n", errno));
return RTErrConvertFromErrno(errno);
}
if ((pBuf = (char*)malloc(cbNeeded)) == NULL)
return VERR_NO_MEMORY;
if (sysctl(aiMib, 6, pBuf, &cbNeeded, NULL, 0) < 0)
{
free(pBuf);
Log(("NetIfList: Failed to retrieve interface table (errno=%d).\n", errno));
return RTErrConvertFromErrno(errno);
}
int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (sock < 0)
{
free(pBuf);
Log(("NetIfList: socket() -> %d\n", errno));
return RTErrConvertFromErrno(errno);
}
char *pEnd = pBuf + cbNeeded;
for (pNext = pBuf; pNext < pEnd;)
{
struct if_msghdr *pIfMsg = (struct if_msghdr *)pNext;
if (pIfMsg->ifm_type != RTM_IFINFO)
{
Log(("NetIfList: Got message %u while expecting %u.\n",
pIfMsg->ifm_type, RTM_IFINFO));
rc = VERR_INTERNAL_ERROR;
break;
}
struct sockaddr_dl *pSdl = (struct sockaddr_dl *)(pIfMsg + 1);
size_t cbNameLen = pSdl->sdl_nlen + 1;
PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
if (!pNew)
{
rc = VERR_NO_MEMORY;
break;
}
memcpy(pNew->MACAddress.au8, LLADDR(pSdl), sizeof(pNew->MACAddress.au8));
pNew->enmMediumType = NETIF_T_ETHERNET;
Assert(sizeof(pNew->szShortName) >= cbNameLen);
strlcpy(pNew->szShortName, pSdl->sdl_data, cbNameLen);
strlcpy(pNew->szName, pSdl->sdl_data, cbNameLen);
/* Generate UUID from name and MAC address. */
RTUUID uuid;
RTUuidClear(&uuid);
memcpy(&uuid, pNew->szShortName, RT_MIN(cbNameLen, sizeof(uuid)));
uuid.Gen.u8ClockSeqHiAndReserved = (uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80;
uuid.Gen.u16TimeHiAndVersion = (uuid.Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000;
memcpy(uuid.Gen.au8Node, pNew->MACAddress.au8, sizeof(uuid.Gen.au8Node));
pNew->Uuid = uuid;
pNext += pIfMsg->ifm_msglen;
while (pNext < pEnd)
{
struct ifa_msghdr *pIfAddrMsg = (struct ifa_msghdr *)pNext;
if (pIfAddrMsg->ifam_type != RTM_NEWADDR)
break;
extractAddressesToNetInfo(pIfAddrMsg->ifam_addrs,
(char *)(pIfAddrMsg + 1),
pIfAddrMsg->ifam_msglen + (char *)pIfAddrMsg,
pNew);
pNext += pIfAddrMsg->ifam_msglen;
}
if (pSdl->sdl_type == IFT_ETHER || pSdl->sdl_type == IFT_L2VLAN)
{
struct ifreq IfReq;
strcpy(IfReq.ifr_name, pNew->szShortName);
if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
{
Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
pNew->enmStatus = NETIF_S_UNKNOWN;
}
else
pNew->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
HostNetworkInterfaceType_T enmType;
if (strncmp("vboxnet", pNew->szName, 7))
enmType = HostNetworkInterfaceType_Bridged;
else
enmType = HostNetworkInterfaceType_HostOnly;
ComObjPtr<HostNetworkInterface> IfObj;
IfObj.createObject();
if (SUCCEEDED(IfObj->init(Bstr(pNew->szName), enmType, pNew)))
/* Make sure the default interface gets to the beginning. */
if ( fDefaultIfaceExistent
&& pIfMsg->ifm_index == u16DefaultIface)
list.push_front(IfObj);
else
list.push_back(IfObj);
}
RTMemFree(pNew);
}
close(sock);
free(pBuf);
return rc;
}
int NetIfCreateHostOnlyNetworkInterface(VirtualBox *pVirtualBox,
IHostNetworkInterface **aHostNetworkInterface,
IProgress **aProgress,
const char *pcszName)
{
#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;
HRESULT hrc = pVirtualBox->COMGETTER(Host)(host.asOutParam());
if (SUCCEEDED(hrc))
{
hrc = progress->init(pVirtualBox, host,
Bstr("Creating host only network interface").raw(),
FALSE /* aCancelable */);
if (SUCCEEDED(hrc))
{
progress.queryInterfaceTo(aProgress);
char szAdpCtl[RTPATH_MAX];
int rc = RTPathExecDir(szAdpCtl, sizeof(szAdpCtl) - sizeof("/" VBOXNETADPCTL_NAME " add"));
if (RT_FAILURE(rc))
{
progress->i_notifyComplete(E_FAIL,
COM_IIDOF(IHostNetworkInterface),
HostNetworkInterface::getStaticComponentName(),
"Failed to get program path, rc=%Rrc\n", rc);
return rc;
}
strcat(szAdpCtl, "/" VBOXNETADPCTL_NAME " ");
if (pcszName && strlen(pcszName) <= RTPATH_MAX - strlen(szAdpCtl) - sizeof(" add"))
{
strcat(szAdpCtl, pcszName);
strcat(szAdpCtl, " add");
}
else
strcat(szAdpCtl, "add");
if (strlen(szAdpCtl) < RTPATH_MAX - sizeof(" 2>&1"))
strcat(szAdpCtl, " 2>&1");
FILE *fp = popen(szAdpCtl, "r");
if (fp)
{
char szBuf[128]; /* We are not interested in long error messages. */
if (fgets(szBuf, sizeof(szBuf), fp))
{
/* Remove trailing new line characters. */
char *pLast = szBuf + strlen(szBuf) - 1;
if (pLast >= szBuf && *pLast == '\n')
*pLast = 0;
if (!strncmp(VBOXNETADPCTL_NAME ":", szBuf, sizeof(VBOXNETADPCTL_NAME)))
{
progress->i_notifyComplete(E_FAIL,
COM_IIDOF(IHostNetworkInterface),
HostNetworkInterface::getStaticComponentName(),
"%s", szBuf);
pclose(fp);
return E_FAIL;
}
size_t cbNameLen = strlen(szBuf) + 1;
PNETIFINFO pInfo = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
if (!pInfo)
rc = VERR_NO_MEMORY;
else
{
strcpy(pInfo->szShortName, szBuf);
strcpy(pInfo->szName, szBuf);
rc = NetIfGetConfigByName(pInfo);
if (RT_FAILURE(rc))
{
progress->i_notifyComplete(E_FAIL,
COM_IIDOF(IHostNetworkInterface),
HostNetworkInterface::getStaticComponentName(),
"Failed to get config info for %s (as reported by '" VBOXNETADPCTL_NAME " add')\n", szBuf);
}
else
{
Bstr IfName(szBuf);
/* create a new uninitialized host interface object */
ComObjPtr<HostNetworkInterface> iface;
iface.createObject();
iface->init(IfName, HostNetworkInterfaceType_HostOnly, pInfo);
iface->i_setVirtualBox(pVirtualBox);
iface.queryInterfaceTo(aHostNetworkInterface);
}
RTMemFree(pInfo);
}
if ((rc = pclose(fp)) != 0)
{
progress->i_notifyComplete(E_FAIL,
COM_IIDOF(IHostNetworkInterface),
HostNetworkInterface::getStaticComponentName(),
"Failed to execute '" VBOXNETADPCTL_NAME " add' (exit status: %d)", rc);
rc = VERR_INTERNAL_ERROR;
}
}
else
{
/* Failed to add an interface */
rc = VERR_PERMISSION_DENIED;
progress->i_notifyComplete(E_FAIL,
COM_IIDOF(IHostNetworkInterface),
HostNetworkInterface::getStaticComponentName(),
"Failed to execute '" VBOXNETADPCTL_NAME " add' (exit status: %d). Check permissions!", rc);
pclose(fp);
}
}
if (RT_SUCCESS(rc))
progress->i_notifyComplete(rc);
else
hrc = E_FAIL;
}
}
return hrc;
#else
NOREF(pVirtualBox);
NOREF(aHostNetworkInterface);
NOREF(aProgress);
NOREF(pcszName);
return VERR_NOT_IMPLEMENTED;
#endif
}
static RTEXITCODE watchdogMain(HandlerArg *a)
{
HRESULT rc = S_OK;
do
{
/* Initialize global weak references. */
g_pEventQ = com::NativeEventQueue::getMainEventQueue();
/*
* Install signal handlers.
*/
signal(SIGINT, signalHandler);
#ifdef SIGBREAK
signal(SIGBREAK, signalHandler);
#endif
/*
* Setup the global event listeners:
* - g_pEventSource for machine events
* - g_pEventSourceClient for VBoxClient events (like VBoxSVC handling)
*/
CHECK_ERROR_BREAK(g_pVirtualBox, COMGETTER(EventSource)(g_pEventSource.asOutParam()));
CHECK_ERROR_BREAK(g_pVirtualBoxClient, COMGETTER(EventSource)(g_pEventSourceClient.asOutParam()));
ComObjPtr<VirtualBoxEventListenerImpl> vboxListenerImpl;
vboxListenerImpl.createObject();
vboxListenerImpl->init(new VirtualBoxEventListener());
com::SafeArray<VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnMachineRegistered);
eventTypes.push_back(VBoxEventType_OnMachineStateChanged);
eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged); /* Processed by g_pEventSourceClient. */
g_pVBoxEventListener = vboxListenerImpl;
CHECK_ERROR_BREAK(g_pEventSource, RegisterListener(g_pVBoxEventListener, ComSafeArrayAsInParam(eventTypes), true /* Active listener */));
CHECK_ERROR_BREAK(g_pEventSourceClient, RegisterListener(g_pVBoxEventListener, ComSafeArrayAsInParam(eventTypes), true /* Active listener */));
/*
* Set up modules.
*/
int vrc = watchdogStartModules();
if (RT_FAILURE(vrc))
break;
for (;;)
{
/*
* Do the actual work.
*/
vrc = RTCritSectEnter(&g_csMachines);
if (RT_SUCCESS(vrc))
{
for (unsigned j = 0; j < RT_ELEMENTS(g_aModules); j++)
if (g_aModules[j].fEnabled)
{
int rc2 = g_aModules[j].pDesc->pfnMain();
if (RT_FAILURE(rc2))
serviceLog("Module '%s' reported an error: %Rrc\n",
g_aModules[j].pDesc->pszName, rc2);
/* Keep going. */
}
int rc2 = RTCritSectLeave(&g_csMachines);
if (RT_SUCCESS(vrc))
vrc = rc2;
AssertRC(vrc);
}
/*
* Process pending events, then wait for new ones. Note, this
* processes NULL events signalling event loop termination.
*/
g_pEventQ->processEventQueue(50);
if (g_fCanceled)
{
serviceLog("Signal caught, exiting ...\n");
break;
}
}
signal(SIGINT, SIG_DFL);
#ifdef SIGBREAK
signal(SIGBREAK, SIG_DFL);
#endif
/* VirtualBox callback unregistration. */
if (g_pVBoxEventListener)
{
if (!g_pEventSource.isNull())
CHECK_ERROR(g_pEventSource, UnregisterListener(g_pVBoxEventListener));
g_pVBoxEventListener.setNull();
}
g_pEventSource.setNull();
g_pEventSourceClient.setNull();
vrc = watchdogShutdownModules();
AssertRC(vrc);
if (RT_FAILURE(vrc))
rc = VBOX_E_IPRT_ERROR;
} while (0);
return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
/**
* Creates a new guest session.
* This will invoke VBoxService running on the guest creating a new (dedicated) guest session
* On older Guest Additions this call has no effect on the guest, and only the credentials will be
* used for starting/impersonating guest processes.
*
* @returns VBox status code.
* @param ssInfo Guest session startup information.
* @param guestCreds Guest OS (user) credentials to use on the guest for creating the session.
* The specified user must be able to logon to the guest and able to start new processes.
* @param pGuestSession Where to store the created guest session on success.
*/
int Guest::i_sessionCreate(const GuestSessionStartupInfo &ssInfo,
const GuestCredentials &guestCreds, ComObjPtr<GuestSession> &pGuestSession)
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
int rc = VERR_MAX_PROCS_REACHED;
if (mData.mGuestSessions.size() >= VBOX_GUESTCTRL_MAX_SESSIONS)
return rc;
try
{
/* Create a new session ID and assign it. */
uint32_t uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
uint32_t uTries = 0;
for (;;)
{
/* Is the context ID already used? */
if (!i_sessionExists(uNewSessionID))
{
rc = VINF_SUCCESS;
break;
}
uNewSessionID++;
if (uNewSessionID >= VBOX_GUESTCTRL_MAX_SESSIONS)
uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
if (++uTries == VBOX_GUESTCTRL_MAX_SESSIONS)
break; /* Don't try too hard. */
}
if (RT_FAILURE(rc)) throw rc;
/* Create the session object. */
HRESULT hr = pGuestSession.createObject();
if (FAILED(hr)) throw VERR_COM_UNEXPECTED;
/** @todo Use an overloaded copy operator. Later. */
GuestSessionStartupInfo startupInfo;
startupInfo.mID = uNewSessionID; /* Assign new session ID. */
startupInfo.mName = ssInfo.mName;
startupInfo.mOpenFlags = ssInfo.mOpenFlags;
startupInfo.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
GuestCredentials guestCredentials;
if (!guestCreds.mUser.isEmpty())
{
/** @todo Use an overloaded copy operator. Later. */
guestCredentials.mUser = guestCreds.mUser;
guestCredentials.mPassword = guestCreds.mPassword;
guestCredentials.mDomain = guestCreds.mDomain;
}
else
{
/* Internal (annonymous) session. */
startupInfo.mIsInternal = true;
}
rc = pGuestSession->init(this, startupInfo, guestCredentials);
if (RT_FAILURE(rc)) throw rc;
/*
* Add session object to our session map. This is necessary
* before calling openSession because the guest calls back
* with the creation result of this session.
*/
mData.mGuestSessions[uNewSessionID] = pGuestSession;
alock.release(); /* Release lock before firing off event. */
fireGuestSessionRegisteredEvent(mEventSource, pGuestSession,
true /* Registered */);
}
catch (int rc2)
{
rc = rc2;
}
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* Initializes the system information object.
*
* @returns COM result indicator
*/
HRESULT SystemProperties::init(VirtualBox *aParent)
{
LogFlowThisFunc(("aParent=%p\n", aParent));
ComAssertRet(aParent, E_FAIL);
/* Enclose the state transition NotReady->InInit->Ready */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), E_FAIL);
unconst(mParent) = aParent;
i_setDefaultMachineFolder(Utf8Str::Empty);
i_setLoggingLevel(Utf8Str::Empty);
i_setDefaultHardDiskFormat(Utf8Str::Empty);
i_setVRDEAuthLibrary(Utf8Str::Empty);
i_setDefaultVRDEExtPack(Utf8Str::Empty);
m->ulLogHistoryCount = 3;
/* On Windows and OS X, HW virtualization use isn't exclusive by
* default so that VT-x or AMD-V can be shared with other
* hypervisors without requiring user intervention.
* NB: See also SystemProperties constructor in settings.h
*/
#if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS)
m->fExclusiveHwVirt = false;
#else
m->fExclusiveHwVirt = true;
#endif
HRESULT rc = S_OK;
/* Fetch info of all available hd backends. */
/// @todo NEWMEDIA VDBackendInfo needs to be improved to let us enumerate
/// any number of backends
VDBACKENDINFO aVDInfo[100];
unsigned cEntries;
int vrc = VDBackendInfo(RT_ELEMENTS(aVDInfo), aVDInfo, &cEntries);
AssertRC(vrc);
if (RT_SUCCESS(vrc))
{
for (unsigned i = 0; i < cEntries; ++ i)
{
ComObjPtr<MediumFormat> hdf;
rc = hdf.createObject();
if (FAILED(rc)) break;
rc = hdf->init(&aVDInfo[i]);
if (FAILED(rc)) break;
m_llMediumFormats.push_back(hdf);
}
}
/* Confirm a successful initialization */
if (SUCCEEDED(rc))
autoInitSpan.setSucceeded();
return rc;
}
int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
{
int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (sock < 0)
{
Log(("NetIfList: socket() -> %d\n", errno));
return NULL;
}
struct ifaddrs *IfAddrs, *pAddr;
int rc = getifaddrs(&IfAddrs);
if (rc)
{
close(sock);
Log(("NetIfList: getifaddrs() -> %d\n", rc));
return VERR_INTERNAL_ERROR;
}
PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
while (pEtherNICs)
{
size_t cbNameLen = strlen(pEtherNICs->szName) + 1;
PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
pNew->MACAddress = pEtherNICs->Mac;
pNew->enmMediumType = NETIF_T_ETHERNET;
pNew->Uuid = pEtherNICs->Uuid;
Assert(sizeof(pNew->szShortName) > sizeof(pEtherNICs->szBSDName));
memcpy(pNew->szShortName, pEtherNICs->szBSDName, sizeof(pEtherNICs->szBSDName));
pNew->szShortName[sizeof(pEtherNICs->szBSDName)] = '\0';
memcpy(pNew->szName, pEtherNICs->szName, cbNameLen);
struct ifreq IfReq;
strcpy(IfReq.ifr_name, pNew->szShortName);
if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
{
Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
pNew->enmStatus = NETIF_S_UNKNOWN;
}
else
pNew->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
for (pAddr = IfAddrs; pAddr != NULL; pAddr = pAddr->ifa_next)
{
if (strcmp(pNew->szShortName, pAddr->ifa_name))
continue;
struct sockaddr_in *pIPAddr, *pIPNetMask;
struct sockaddr_in6 *pIPv6Addr, *pIPv6NetMask;
switch (pAddr->ifa_addr->sa_family)
{
case AF_INET:
if (pNew->IPAddress.u)
break;
pIPAddr = (struct sockaddr_in *)pAddr->ifa_addr;
Assert(sizeof(pNew->IPAddress) == sizeof(pIPAddr->sin_addr));
pNew->IPAddress.u = pIPAddr->sin_addr.s_addr;
pIPNetMask = (struct sockaddr_in *)pAddr->ifa_netmask;
Assert(pIPNetMask->sin_family == AF_INET);
Assert(sizeof(pNew->IPNetMask) == sizeof(pIPNetMask->sin_addr));
pNew->IPNetMask.u = pIPNetMask->sin_addr.s_addr;
break;
case AF_INET6:
if (pNew->IPv6Address.s.Lo || pNew->IPv6Address.s.Hi)
break;
pIPv6Addr = (struct sockaddr_in6 *)pAddr->ifa_addr;
Assert(sizeof(pNew->IPv6Address) == sizeof(pIPv6Addr->sin6_addr));
memcpy(pNew->IPv6Address.au8,
pIPv6Addr->sin6_addr.__u6_addr.__u6_addr8,
sizeof(pNew->IPv6Address));
pIPv6NetMask = (struct sockaddr_in6 *)pAddr->ifa_netmask;
Assert(pIPv6NetMask->sin6_family == AF_INET6);
Assert(sizeof(pNew->IPv6NetMask) == sizeof(pIPv6NetMask->sin6_addr));
memcpy(pNew->IPv6NetMask.au8,
pIPv6NetMask->sin6_addr.__u6_addr.__u6_addr8,
sizeof(pNew->IPv6NetMask));
break;
}
}
ComObjPtr<HostNetworkInterface> IfObj;
IfObj.createObject();
if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), HostNetworkInterfaceType_Bridged, pNew)))
list.push_back(IfObj);
RTMemFree(pNew);
/* next, free current */
void *pvFree = pEtherNICs;
pEtherNICs = pEtherNICs->pNext;
RTMemFree(pvFree);
}
freeifaddrs(IfAddrs);
close(sock);
return VINF_SUCCESS;
}
/**
* @note Locks this object for writing, together with the peer object (also
* for writing) if there is one.
*/
void USBDeviceFilters::i_commit()
{
/* sanity */
AutoCaller autoCaller(this);
AssertComRCReturnVoid(autoCaller.rc());
/* sanity too */
AutoCaller peerCaller(m->pPeer);
AssertComRCReturnVoid(peerCaller.rc());
/* lock both for writing since we modify both (mPeer is "master" so locked
* first) */
AutoMultiWriteLock2 alock(m->pPeer, this COMMA_LOCKVAL_SRC_POS);
#ifdef VBOX_WITH_USB
bool commitFilters = false;
if (m->llDeviceFilters.isBackedUp())
{
m->llDeviceFilters.commit();
/* apply changes to peer */
if (m->pPeer)
{
AutoWriteLock peerlock(m->pPeer COMMA_LOCKVAL_SRC_POS);
/* commit all changes to new filters (this will reshare data with
* peers for those who have peers) */
DeviceFilterList *newList = new DeviceFilterList();
DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
while (it != m->llDeviceFilters->end())
{
(*it)->i_commit();
/* look if this filter has a peer filter */
ComObjPtr<USBDeviceFilter> peer = (*it)->i_peer();
if (!peer)
{
/* no peer means the filter is a newly created one;
* create a peer owning data this filter share it with */
peer.createObject();
peer->init(m->pPeer, *it, true /* aReshare */);
}
else
{
/* remove peer from the old list */
m->pPeer->m->llDeviceFilters->remove(peer);
}
/* and add it to the new list */
newList->push_back(peer);
++it;
}
/* uninit old peer's filters that are left */
it = m->pPeer->m->llDeviceFilters->begin();
while (it != m->pPeer->m->llDeviceFilters->end())
{
(*it)->uninit();
++it;
}
/* attach new list of filters to our peer */
m->pPeer->m->llDeviceFilters.attach(newList);
}
else
{
/* we have no peer (our parent is the newly created machine);
* just commit changes to filters */
commitFilters = true;
}
}
else
{
/* the list of filters itself is not changed,
* just commit changes to filters themselves */
commitFilters = true;
}
if (commitFilters)
{
DeviceFilterList::const_iterator it = m->llDeviceFilters->begin();
while (it != m->llDeviceFilters->end())
{
(*it)->i_commit();
++it;
}
}
#endif /* VBOX_WITH_USB */
}
/**
* Process any relevant changes in the attached USB devices.
*
* Except for the first call, this is always running on the service thread.
*/
void USBProxyService::processChanges(void)
{
LogFlowThisFunc(("\n"));
/*
* Get the sorted list of USB devices.
*/
PUSBDEVICE pDevices = getDevices();
pDevices = sortDevices(pDevices);
// get a list of all running machines while we're outside the lock
// (getOpenedMachines requests higher priority locks)
SessionMachinesList llOpenedMachines;
mHost->i_parent()->i_getOpenedMachines(llOpenedMachines);
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
/*
* Compare previous list with the new list of devices
* and merge in any changes while notifying Host.
*/
HostUSBDeviceList::iterator it = this->mDevices.begin();
while ( it != mDevices.end()
|| pDevices)
{
ComObjPtr<HostUSBDevice> pHostDevice;
if (it != mDevices.end())
pHostDevice = *it;
/*
* Assert that the object is still alive (we still reference it in
* the collection and we're the only one who calls uninit() on it.
*/
AutoCaller devCaller(pHostDevice.isNull() ? NULL : pHostDevice);
AssertComRC(devCaller.rc());
/*
* Lock the device object since we will read/write its
* properties. All Host callbacks also imply the object is locked.
*/
AutoWriteLock devLock(pHostDevice.isNull() ? NULL : pHostDevice
COMMA_LOCKVAL_SRC_POS);
/*
* Compare.
*/
int iDiff;
if (pHostDevice.isNull())
iDiff = 1;
else
{
if (!pDevices)
iDiff = -1;
else
iDiff = pHostDevice->i_compare(pDevices);
}
if (!iDiff)
{
/*
* The device still there, update the state and move on. The PUSBDEVICE
* structure is eaten by updateDeviceState / HostUSBDevice::updateState().
*/
PUSBDEVICE pCur = pDevices;
pDevices = pDevices->pNext;
pCur->pPrev = pCur->pNext = NULL;
bool fRunFilters = false;
SessionMachine *pIgnoreMachine = NULL;
devLock.release();
alock.release();
if (updateDeviceState(pHostDevice, pCur, &fRunFilters, &pIgnoreMachine))
deviceChanged(pHostDevice,
(fRunFilters ? &llOpenedMachines : NULL),
pIgnoreMachine);
alock.acquire();
++it;
}
else
{
if (iDiff > 0)
{
/*
* Head of pDevices was attached.
*/
PUSBDEVICE pNew = pDevices;
pDevices = pDevices->pNext;
pNew->pPrev = pNew->pNext = NULL;
ComObjPtr<HostUSBDevice> NewObj;
NewObj.createObject();
NewObj->init(pNew, this);
Log(("USBProxyService::processChanges: attached %p {%s} %s / %p:{.idVendor=%#06x, .idProduct=%#06x, .pszProduct=\"%s\", .pszManufacturer=\"%s\"}\n",
(HostUSBDevice *)NewObj,
NewObj->i_getName().c_str(),
NewObj->i_getStateName(),
pNew,
pNew->idVendor,
pNew->idProduct,
pNew->pszProduct,
pNew->pszManufacturer));
mDevices.insert(it, NewObj);
devLock.release();
alock.release();
deviceAdded(NewObj, llOpenedMachines, pNew);
alock.acquire();
}
else
{
/*
* Check if the device was actually detached or logically detached
* as the result of a re-enumeration.
*/
if (!pHostDevice->i_wasActuallyDetached())
++it;
else
{
it = mDevices.erase(it);
devLock.release();
alock.release();
deviceRemoved(pHostDevice);
Log(("USBProxyService::processChanges: detached %p {%s}\n",
(HostUSBDevice *)pHostDevice,
pHostDevice->i_getName().c_str()));
/* from now on, the object is no more valid,
* uninitialize to avoid abuse */
devCaller.release();
pHostDevice->uninit();
alock.acquire();
}
}
}
} /* while */
LogFlowThisFunc(("returns void\n"));
}
STDMETHODIMP GuestDirectory::Read(IFsObjInfo **aInfo)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
GuestProcessStreamBlock curBlock;
int guestRc;
int rc = mData.mProcessTool.WaitEx(GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK,
&curBlock, &guestRc);
/*
* Note: The guest process can still be around to serve the next
* upcoming stream block next time.
*/
if ( RT_SUCCESS(rc)
&& !mData.mProcessTool.IsRunning())
{
rc = mData.mProcessTool.TerminatedOk(NULL /* Exit code */);
if (rc == VERR_NOT_EQUAL)
rc = VERR_ACCESS_DENIED;
}
if (RT_SUCCESS(rc))
{
if (curBlock.GetCount()) /* Did we get content? */
{
GuestFsObjData objData;
rc = objData.FromLs(curBlock);
if (RT_FAILURE(rc))
rc = VERR_PATH_NOT_FOUND;
if (RT_SUCCESS(rc))
{
/* Create the object. */
ComObjPtr<GuestFsObjInfo> pFsObjInfo;
HRESULT hr2 = pFsObjInfo.createObject();
if (FAILED(hr2))
rc = VERR_COM_UNEXPECTED;
if (RT_SUCCESS(rc))
rc = pFsObjInfo->init(objData);
if (RT_SUCCESS(rc))
{
/* Return info object to the caller. */
hr2 = pFsObjInfo.queryInterfaceTo(aInfo);
if (FAILED(hr2))
rc = VERR_COM_UNEXPECTED;
}
}
}
else
{
/* Nothing to read anymore. Tell the caller. */
rc = VERR_NO_MORE_FILES;
}
}
HRESULT hr = S_OK;
if (RT_FAILURE(rc)) /** @todo Add more errors here. */
{
switch (rc)
{
case VERR_GSTCTL_GUEST_ERROR:
hr = GuestProcess::setErrorExternal(this, guestRc);
break;
case VERR_ACCESS_DENIED:
hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Unable to read / access denied"),
mData.mName.c_str());
break;
case VERR_PATH_NOT_FOUND:
hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Path not found"),
mData.mName.c_str());
break;
case VERR_NO_MORE_FILES:
/* See SDK reference. */
hr = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No more entries for directory \"%s\""),
mData.mName.c_str());
break;
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Error while reading directory \"%s\": %Rrc\n"),
mData.mName.c_str(), rc);
break;
}
}
LogFlowFuncLeaveRC(rc);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
/**
* Start teleporter to the specified target.
*
* @returns COM status code.
*
* @param aHostname The name of the target host.
* @param aPort The TCP port number.
* @param aPassword The password.
* @param aMaxDowntime Max allowed "downtime" in milliseconds.
* @param aProgress Where to return the progress object.
*/
STDMETHODIMP
Console::Teleport(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress)
{
/*
* Validate parameters, check+hold object status, write lock the object
* and validate the state.
*/
CheckComArgOutPointerValid(aProgress);
CheckComArgStrNotEmptyOrNull(aHostname);
CheckComArgStrNotEmptyOrNull(aPassword);
CheckComArgExprMsg(aPort, aPort > 0 && aPort <= 65535, ("is %u", aPort));
CheckComArgExprMsg(aMaxDowntime, aMaxDowntime > 0, ("is %u", aMaxDowntime));
Utf8Str strPassword(aPassword);
if (!strPassword.isEmpty())
{
if (VBoxIsPasswordHashed(&strPassword))
return setError(E_INVALIDARG, tr("The specified password resembles a hashed password, expected plain text"));
VBoxHashPassword(&strPassword);
}
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
switch (mMachineState)
{
case MachineState_Running:
case MachineState_Paused:
break;
default:
return setError(VBOX_E_INVALID_VM_STATE,
tr("Invalid machine state: %s (must be Running or Paused)"),
Global::stringifyMachineState(mMachineState));
}
/*
* Create a progress object, spawn a worker thread and change the state.
* Note! The thread won't start working until we release the lock.
*/
LogFlowThisFunc(("Initiating TELEPORT request...\n"));
ComObjPtr<Progress> ptrProgress;
HRESULT hrc = ptrProgress.createObject();
if (SUCCEEDED(hrc))
hrc = ptrProgress->init(static_cast<IConsole *>(this),
Bstr(tr("Teleporter")).raw(),
TRUE /*aCancelable*/);
if (FAILED(hrc))
return hrc;
TeleporterStateSrc *pState = new TeleporterStateSrc(this, mpUVM, ptrProgress, mMachineState);
pState->mstrPassword = strPassword;
pState->mstrHostname = aHostname;
pState->muPort = aPort;
pState->mcMsMaxDowntime = aMaxDowntime;
void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
ptrProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser);
int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
RTTHREADTYPE_EMULATION, 0 /*fFlags*/, "Teleport");
if (RT_SUCCESS(vrc))
{
if (mMachineState == MachineState_Running)
hrc = setMachineState(MachineState_Teleporting);
else
hrc = setMachineState(MachineState_TeleportingPausedVM);
if (SUCCEEDED(hrc))
{
ptrProgress.queryInterfaceTo(aProgress);
mptrCancelableProgress = ptrProgress;
}
else
ptrProgress->Cancel();
}
else
{
ptrProgress->setCancelCallback(NULL, NULL);
delete pState;
hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc);
}
return hrc;
}
UIConsoleEventHandler::UIConsoleEventHandler(UISession *pSession)
: m_pSession(pSession)
{
Assert(pSession);
// RTPrintf("Self add: %RTthrd\n", RTThreadSelf());
ComObjPtr<UIMainEventListenerImpl> pListener;
pListener.createObject();
pListener->init(new UIMainEventListener(), this);
m_mainEventListener = CEventListener(pListener);
QVector<KVBoxEventType> events;
events
<< KVBoxEventType_OnMousePointerShapeChanged
<< KVBoxEventType_OnMouseCapabilityChanged
<< KVBoxEventType_OnKeyboardLedsChanged
<< KVBoxEventType_OnStateChanged
<< KVBoxEventType_OnAdditionsStateChanged
<< KVBoxEventType_OnNetworkAdapterChanged
<< KVBoxEventType_OnMediumChanged
<< KVBoxEventType_OnVRDEServerChanged
<< KVBoxEventType_OnVRDEServerInfoChanged
<< KVBoxEventType_OnUSBControllerChanged
<< KVBoxEventType_OnUSBDeviceStateChanged
<< KVBoxEventType_OnSharedFolderChanged
<< KVBoxEventType_OnRuntimeError
<< KVBoxEventType_OnCanShowWindow
<< KVBoxEventType_OnShowWindow
<< KVBoxEventType_OnCPUExecutionCapChanged
<< KVBoxEventType_OnGuestMonitorChanged;
const CConsole &console = m_pSession->session().GetConsole();
console.GetEventSource().RegisterListener(m_mainEventListener, events, TRUE);
AssertWrapperOk(console);
connect(pListener->getWrapped(), SIGNAL(sigMousePointerShapeChange(bool, bool, QPoint, QSize, QVector<uint8_t>)),
this, SIGNAL(sigMousePointerShapeChange(bool, bool, QPoint, QSize, QVector<uint8_t>)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigMouseCapabilityChange(bool, bool, bool)),
this, SIGNAL(sigMouseCapabilityChange(bool, bool, bool)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigKeyboardLedsChangeEvent(bool, bool, bool)),
this, SIGNAL(sigKeyboardLedsChangeEvent(bool, bool, bool)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigStateChange(KMachineState)),
this, SIGNAL(sigStateChange(KMachineState)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigAdditionsChange()),
this, SIGNAL(sigAdditionsChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigNetworkAdapterChange(CNetworkAdapter)),
this, SIGNAL(sigNetworkAdapterChange(CNetworkAdapter)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigMediumChange(CMediumAttachment)),
this, SIGNAL(sigMediumChange(CMediumAttachment)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigVRDEChange()),
this, SIGNAL(sigVRDEChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigUSBControllerChange()),
this, SIGNAL(sigUSBControllerChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigUSBDeviceStateChange(CUSBDevice, bool, CVirtualBoxErrorInfo)),
this, SIGNAL(sigUSBDeviceStateChange(CUSBDevice, bool, CVirtualBoxErrorInfo)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigSharedFolderChange()),
this, SIGNAL(sigSharedFolderChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigRuntimeError(bool, QString, QString)),
this, SIGNAL(sigRuntimeError(bool, QString, QString)),
Qt::QueuedConnection);
/* This is a vetoable event, so we have to respond to the event and have to
* use a direct connection therefor. */
connect(pListener->getWrapped(), SIGNAL(sigCanShowWindow(bool&, QString&)),
this, SLOT(sltCanShowWindow(bool&, QString&)),
Qt::DirectConnection);
/* This returns a winId, so we have to respond to the event and have to use
* a direct connection therefor. */
connect(pListener->getWrapped(), SIGNAL(sigShowWindow(LONG64&)),
this, SLOT(sltShowWindow(LONG64&)),
Qt::DirectConnection);
connect(pListener->getWrapped(), SIGNAL(sigCPUExecutionCapChange()),
this, SIGNAL(sigCPUExecutionCapChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
this, SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
Qt::QueuedConnection);
}
/**
* Initializes a file object but does *not* open the file on the guest
* yet. This is done in the dedidcated openFile call.
*
* @return IPRT status code.
* @param pConsole Pointer to console object.
* @param pSession Pointer to session object.
* @param uFileID Host-based file ID (part of the context ID).
* @param openInfo File opening information.
*/
int GuestFile::init(Console *pConsole, GuestSession *pSession,
ULONG uFileID, const GuestFileOpenInfo &openInfo)
{
LogFlowThisFunc(("pConsole=%p, pSession=%p, uFileID=%RU32, strPath=%s\n",
pConsole, pSession, uFileID, openInfo.mFileName.c_str()));
AssertPtrReturn(pConsole, VERR_INVALID_POINTER);
AssertPtrReturn(pSession, VERR_INVALID_POINTER);
/* Enclose the state transition NotReady->InInit->Ready. */
AutoInitSpan autoInitSpan(this);
AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
#ifndef VBOX_WITH_GUEST_CONTROL
autoInitSpan.setSucceeded();
return VINF_SUCCESS;
#else
int vrc = bindToSession(pConsole, pSession, uFileID /* Object ID */);
if (RT_SUCCESS(vrc))
{
mSession = pSession;
mData.mID = uFileID;
mData.mInitialSize = 0;
mData.mStatus = FileStatus_Undefined;
mData.mOpenInfo = openInfo;
unconst(mEventSource).createObject();
HRESULT hr = mEventSource->init();
if (FAILED(hr))
vrc = VERR_COM_UNEXPECTED;
}
if (RT_SUCCESS(vrc))
{
try
{
GuestFileListener *pListener = new GuestFileListener();
ComObjPtr<GuestFileListenerImpl> thisListener;
HRESULT hr = thisListener.createObject();
if (SUCCEEDED(hr))
hr = thisListener->init(pListener, this);
if (SUCCEEDED(hr))
{
com::SafeArray <VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileOffsetChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileRead);
eventTypes.push_back(VBoxEventType_OnGuestFileWrite);
hr = mEventSource->RegisterListener(thisListener,
ComSafeArrayAsInParam(eventTypes),
TRUE /* Active listener */);
if (SUCCEEDED(hr))
{
vrc = baseInit();
if (RT_SUCCESS(vrc))
{
mLocalListener = thisListener;
}
}
else
vrc = VERR_COM_UNEXPECTED;
}
else
vrc = VERR_COM_UNEXPECTED;
}
catch(std::bad_alloc &)
{
vrc = VERR_NO_MEMORY;
}
}
if (RT_SUCCESS(vrc))
{
/* Confirm a successful initialization when it's the case. */
autoInitSpan.setSucceeded();
}
else
autoInitSpan.setFailed();
LogFlowFuncLeaveRC(vrc);
return vrc;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
STDMETHODIMP GuestDirectory::Read(IFsObjInfo **aInfo)
{
#ifndef VBOX_WITH_GUEST_CONTROL
ReturnComNotImplemented();
#else
LogFlowThisFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
ComObjPtr<GuestProcess> pProcess = mData.mProcess;
Assert(!pProcess.isNull());
GuestProcessStreamBlock streamBlock;
GuestFsObjData objData;
int rc = parseData(streamBlock);
if ( RT_FAILURE(rc)
|| streamBlock.IsEmpty()) /* More data needed. */
{
rc = pProcess->waitForStart(30 * 1000 /* 30s timeout */);
}
if (RT_SUCCESS(rc))
{
BYTE byBuf[_64K];
size_t cbRead = 0;
/** @todo Merge with GuestSession::queryFileInfoInternal. */
for (;RT_SUCCESS(rc);)
{
GuestProcessWaitResult waitRes;
rc = pProcess->waitFor( ProcessWaitForFlag_Terminate
| ProcessWaitForFlag_StdOut,
30 * 1000 /* Timeout */, waitRes);
if ( RT_FAILURE(rc)
|| waitRes.mResult == ProcessWaitResult_Terminate
|| waitRes.mResult == ProcessWaitResult_Error
|| waitRes.mResult == ProcessWaitResult_Timeout)
{
if (RT_FAILURE(waitRes.mRC))
rc = waitRes.mRC;
break;
}
rc = pProcess->readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
30 * 1000 /* Timeout */, byBuf, sizeof(byBuf),
&cbRead);
if (RT_FAILURE(rc))
break;
if (cbRead)
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
rc = mData.mStream.AddData(byBuf, cbRead);
if (RT_FAILURE(rc))
break;
LogFlowThisFunc(("rc=%Rrc, cbRead=%RU64, cbStreamOut=%RU32\n",
rc, cbRead, mData.mStream.GetSize()));
rc = parseData(streamBlock);
if (RT_SUCCESS(rc))
{
/* Parsing the current stream block succeeded so
* we don't need more at the moment. */
break;
}
}
}
LogFlowThisFunc(("Reading done with rc=%Rrc, cbRead=%RU64, cbStream=%RU32\n",
rc, cbRead, mData.mStream.GetSize()));
if (RT_SUCCESS(rc))
{
rc = parseData(streamBlock);
if (rc == VERR_NO_DATA) /* Since this is the last parsing call, this is ok. */
rc = VINF_SUCCESS;
}
/*
* Note: The guest process can still be around to serve the next
* upcoming stream block next time.
*/
if (RT_SUCCESS(rc))
{
/** @todo Move into common function. */
ProcessStatus_T procStatus = ProcessStatus_Undefined;
LONG exitCode = 0;
HRESULT hr2 = pProcess->COMGETTER(Status(&procStatus));
ComAssertComRC(hr2);
hr2 = pProcess->COMGETTER(ExitCode(&exitCode));
ComAssertComRC(hr2);
if ( ( procStatus != ProcessStatus_Started
&& procStatus != ProcessStatus_Paused
&& procStatus != ProcessStatus_Terminating
)
&& exitCode != 0)
{
rc = VERR_ACCESS_DENIED;
}
}
}
if (RT_SUCCESS(rc))
{
if (streamBlock.GetCount()) /* Did we get content? */
{
rc = objData.FromLs(streamBlock);
if (RT_FAILURE(rc))
rc = VERR_PATH_NOT_FOUND;
if (RT_SUCCESS(rc))
{
/* Create the object. */
ComObjPtr<GuestFsObjInfo> pFsObjInfo;
HRESULT hr2 = pFsObjInfo.createObject();
if (FAILED(hr2))
rc = VERR_COM_UNEXPECTED;
if (RT_SUCCESS(rc))
rc = pFsObjInfo->init(objData);
if (RT_SUCCESS(rc))
{
/* Return info object to the caller. */
hr2 = pFsObjInfo.queryInterfaceTo(aInfo);
if (FAILED(hr2))
rc = VERR_COM_UNEXPECTED;
}
}
}
else
{
/* Nothing to read anymore. Tell the caller. */
rc = VERR_NO_MORE_FILES;
}
}
HRESULT hr = S_OK;
if (RT_FAILURE(rc)) /** @todo Add more errors here. */
{
switch (rc)
{
case VERR_ACCESS_DENIED:
hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Unable to read / access denied"),
mData.mName.c_str());
break;
case VERR_PATH_NOT_FOUND:
hr = setError(VBOX_E_IPRT_ERROR, tr("Reading directory \"%s\" failed: Path not found"),
mData.mName.c_str());
break;
case VERR_NO_MORE_FILES:
hr = setError(VBOX_E_OBJECT_NOT_FOUND, tr("No more entries for directory \"%s\""),
mData.mName.c_str());
break;
default:
hr = setError(VBOX_E_IPRT_ERROR, tr("Error while reading directory \"%s\": %Rrc\n"),
mData.mName.c_str(), rc);
break;
}
}
LogFlowFuncLeaveRC(rc);
return hr;
#endif /* VBOX_WITH_GUEST_CONTROL */
}
/**
* Entry point.
*/
extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
{
const char *vrdePort = NULL;
const char *vrdeAddress = NULL;
const char *vrdeEnabled = NULL;
unsigned cVRDEProperties = 0;
const char *aVRDEProperties[16];
#ifdef VBOX_WITH_VNC
bool fVNCEnable = false;
unsigned uVNCPort = 0; /* default port */
char const *pszVNCPassword = NULL; /* no password */
#endif
unsigned fRawR0 = ~0U;
unsigned fRawR3 = ~0U;
unsigned fPATM = ~0U;
unsigned fCSAM = ~0U;
#ifdef VBOX_FFMPEG
unsigned fFFMPEG = 0;
unsigned long ulFrameWidth = 800;
unsigned long ulFrameHeight = 600;
unsigned long ulBitRate = 300000;
char pszMPEGFile[RTPATH_MAX];
const char *pszFileNameParam = "VBox-%d.vob";
#endif /* VBOX_FFMPEG */
LogFlow (("VBoxHeadless STARTED.\n"));
RTPrintf (VBOX_PRODUCT " Headless Interface " VBOX_VERSION_STRING "\n"
"(C) 2008-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
"All rights reserved.\n\n");
#ifdef VBOX_FFMPEG
/* Parse the environment */
parse_environ(&ulFrameWidth, &ulFrameHeight, &ulBitRate, &pszFileNameParam);
#endif
enum eHeadlessOptions
{
OPT_RAW_R0 = 0x100,
OPT_NO_RAW_R0,
OPT_RAW_R3,
OPT_NO_RAW_R3,
OPT_PATM,
OPT_NO_PATM,
OPT_CSAM,
OPT_NO_CSAM,
OPT_COMMENT
};
static const RTGETOPTDEF s_aOptions[] =
{
{ "-startvm", 's', RTGETOPT_REQ_STRING },
{ "--startvm", 's', RTGETOPT_REQ_STRING },
{ "-vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
{ "--vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
{ "-vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
{ "--vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
{ "-vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
{ "--vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
{ "-vrde", 'v', RTGETOPT_REQ_STRING },
{ "--vrde", 'v', RTGETOPT_REQ_STRING },
{ "-vrdeproperty", 'e', RTGETOPT_REQ_STRING },
{ "--vrdeproperty", 'e', RTGETOPT_REQ_STRING },
#ifdef VBOX_WITH_VNC
{ "--vncport", 'm', RTGETOPT_REQ_INT32 },
{ "--vncpass", 'o', RTGETOPT_REQ_STRING },
{ "--vnc", 'n', 0 },
#endif /* VBOX_WITH_VNC */
{ "-rawr0", OPT_RAW_R0, 0 },
{ "--rawr0", OPT_RAW_R0, 0 },
{ "-norawr0", OPT_NO_RAW_R0, 0 },
{ "--norawr0", OPT_NO_RAW_R0, 0 },
{ "-rawr3", OPT_RAW_R3, 0 },
{ "--rawr3", OPT_RAW_R3, 0 },
{ "-norawr3", OPT_NO_RAW_R3, 0 },
{ "--norawr3", OPT_NO_RAW_R3, 0 },
{ "-patm", OPT_PATM, 0 },
{ "--patm", OPT_PATM, 0 },
{ "-nopatm", OPT_NO_PATM, 0 },
{ "--nopatm", OPT_NO_PATM, 0 },
{ "-csam", OPT_CSAM, 0 },
{ "--csam", OPT_CSAM, 0 },
{ "-nocsam", OPT_NO_CSAM, 0 },
{ "--nocsam", OPT_NO_CSAM, 0 },
#ifdef VBOX_FFMPEG
{ "-capture", 'c', 0 },
{ "--capture", 'c', 0 },
{ "--width", 'w', RTGETOPT_REQ_UINT32 },
{ "--height", 'h', RTGETOPT_REQ_UINT32 }, /* great choice of short option! */
{ "--bitrate", 'r', RTGETOPT_REQ_UINT32 },
{ "--filename", 'f', RTGETOPT_REQ_STRING },
#endif /* VBOX_FFMPEG defined */
{ "-comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
{ "--comment", OPT_COMMENT, RTGETOPT_REQ_STRING }
};
const char *pcszNameOrUUID = NULL;
// parse the command line
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch(ch)
{
case 's':
pcszNameOrUUID = ValueUnion.psz;
break;
case 'p':
RTPrintf("Warning: '-p' or '-vrdpport' are deprecated. Use '-e \"TCP/Ports=%s\"'\n", ValueUnion.psz);
vrdePort = ValueUnion.psz;
break;
case 'a':
RTPrintf("Warning: '-a' or '-vrdpaddress' are deprecated. Use '-e \"TCP/Address=%s\"'\n", ValueUnion.psz);
vrdeAddress = ValueUnion.psz;
break;
case 'v':
vrdeEnabled = ValueUnion.psz;
break;
case 'e':
if (cVRDEProperties < RT_ELEMENTS(aVRDEProperties))
aVRDEProperties[cVRDEProperties++] = ValueUnion.psz;
else
RTPrintf("Warning: too many VRDE properties. Ignored: '%s'\n", ValueUnion.psz);
break;
#ifdef VBOX_WITH_VNC
case 'n':
fVNCEnable = true;
break;
case 'm':
uVNCPort = ValueUnion.i32;
break;
case 'o':
pszVNCPassword = ValueUnion.psz;
break;
#endif /* VBOX_WITH_VNC */
case OPT_RAW_R0:
fRawR0 = true;
break;
case OPT_NO_RAW_R0:
fRawR0 = false;
break;
case OPT_RAW_R3:
fRawR3 = true;
break;
case OPT_NO_RAW_R3:
fRawR3 = false;
break;
case OPT_PATM:
fPATM = true;
break;
case OPT_NO_PATM:
fPATM = false;
break;
case OPT_CSAM:
fCSAM = true;
break;
case OPT_NO_CSAM:
fCSAM = false;
break;
#ifdef VBOX_FFMPEG
case 'c':
fFFMPEG = true;
break;
case 'w':
ulFrameWidth = ValueUnion.u32;
break;
case 'r':
ulBitRate = ValueUnion.u32;
break;
case 'f':
pszFileNameParam = ValueUnion.psz;
break;
#endif /* VBOX_FFMPEG defined */
case 'h':
#ifdef VBOX_FFMPEG
if ((GetState.pDef->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
{
ulFrameHeight = ValueUnion.u32;
break;
}
#endif
show_usage();
return 0;
case OPT_COMMENT:
/* nothing to do */
break;
case 'V':
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
return 0;
default:
ch = RTGetOptPrintError(ch, &ValueUnion);
show_usage();
return ch;
}
}
#ifdef VBOX_FFMPEG
if (ulFrameWidth < 512 || ulFrameWidth > 2048 || ulFrameWidth % 2)
{
LogError("VBoxHeadless: ERROR: please specify an even frame width between 512 and 2048", 0);
return 1;
}
if (ulFrameHeight < 384 || ulFrameHeight > 1536 || ulFrameHeight % 2)
{
LogError("VBoxHeadless: ERROR: please specify an even frame height between 384 and 1536", 0);
return 1;
}
if (ulBitRate < 300000 || ulBitRate > 1000000)
{
LogError("VBoxHeadless: ERROR: please specify an even bitrate between 300000 and 1000000", 0);
return 1;
}
/* Make sure we only have %d or %u (or none) in the file name specified */
char *pcPercent = (char*)strchr(pszFileNameParam, '%');
if (pcPercent != 0 && *(pcPercent + 1) != 'd' && *(pcPercent + 1) != 'u')
{
LogError("VBoxHeadless: ERROR: Only %%d and %%u are allowed in the capture file name.", -1);
return 1;
}
/* And no more than one % in the name */
if (pcPercent != 0 && strchr(pcPercent + 1, '%') != 0)
{
LogError("VBoxHeadless: ERROR: Only one format modifier is allowed in the capture file name.", -1);
return 1;
}
RTStrPrintf(&pszMPEGFile[0], RTPATH_MAX, pszFileNameParam, RTProcSelf());
#endif /* defined VBOX_FFMPEG */
if (!pcszNameOrUUID)
{
show_usage();
return 1;
}
HRESULT rc;
rc = com::Initialize();
if (FAILED(rc))
{
RTPrintf("VBoxHeadless: ERROR: failed to initialize COM!\n");
return 1;
}
ComPtr<IVirtualBoxClient> pVirtualBoxClient;
ComPtr<IVirtualBox> virtualBox;
ComPtr<ISession> session;
ComPtr<IMachine> machine;
bool fSessionOpened = false;
ComPtr<IEventListener> vboxClientListener;
ComPtr<IEventListener> vboxListener;
ComObjPtr<ConsoleEventListenerImpl> consoleListener;
do
{
rc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
if (FAILED(rc))
{
RTPrintf("VBoxHeadless: ERROR: failed to create the VirtualBoxClient object!\n");
com::ErrorInfo info;
if (!info.isFullAvailable() && !info.isBasicAvailable())
{
com::GluePrintRCMessage(rc);
RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
}
else
GluePrintErrorInfo(info);
break;
}
rc = pVirtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
if (FAILED(rc))
{
RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", rc);
break;
}
rc = pVirtualBoxClient->COMGETTER(Session)(session.asOutParam());
if (FAILED(rc))
{
RTPrintf("Failed to get session object (rc=%Rhrc)!\n", rc);
break;
}
ComPtr<IMachine> m;
rc = virtualBox->FindMachine(Bstr(pcszNameOrUUID).raw(), m.asOutParam());
if (FAILED(rc))
{
LogError("Invalid machine name or UUID!\n", rc);
break;
}
Bstr id;
m->COMGETTER(Id)(id.asOutParam());
AssertComRC(rc);
if (FAILED(rc))
break;
Log(("VBoxHeadless: Opening a session with machine (id={%s})...\n",
Utf8Str(id).c_str()));
// open a session
CHECK_ERROR_BREAK(m, LockMachine(session, LockType_Write));
fSessionOpened = true;
/* get the console */
ComPtr<IConsole> console;
CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
/* get the mutable machine */
CHECK_ERROR_BREAK(console, COMGETTER(Machine)(machine.asOutParam()));
ComPtr<IDisplay> display;
CHECK_ERROR_BREAK(console, COMGETTER(Display)(display.asOutParam()));
#ifdef VBOX_FFMPEG
IFramebuffer *pFramebuffer = 0;
RTLDRMOD hLdrFFmpegFB;
PFNREGISTERFFMPEGFB pfnRegisterFFmpegFB;
if (fFFMPEG)
{
HRESULT rcc = S_OK;
int rrc = VINF_SUCCESS;
RTERRINFOSTATIC ErrInfo;
Log2(("VBoxHeadless: loading VBoxFFmpegFB shared library\n"));
RTErrInfoInitStatic(&ErrInfo);
rrc = SUPR3HardenedLdrLoadAppPriv("VBoxFFmpegFB", &hLdrFFmpegFB, RTLDRLOAD_FLAGS_LOCAL, &ErrInfo.Core);
if (RT_SUCCESS(rrc))
{
Log2(("VBoxHeadless: looking up symbol VBoxRegisterFFmpegFB\n"));
rrc = RTLdrGetSymbol(hLdrFFmpegFB, "VBoxRegisterFFmpegFB",
reinterpret_cast<void **>(&pfnRegisterFFmpegFB));
if (RT_FAILURE(rrc))
LogError("Failed to load the video capture extension, possibly due to a damaged file\n", rrc);
}
else
LogError("Failed to load the video capture extension\n", rrc); /** @todo stupid function, no formatting options. */
if (RT_SUCCESS(rrc))
{
Log2(("VBoxHeadless: calling pfnRegisterFFmpegFB\n"));
rcc = pfnRegisterFFmpegFB(ulFrameWidth, ulFrameHeight, ulBitRate,
pszMPEGFile, &pFramebuffer);
if (rcc != S_OK)
LogError("Failed to initialise video capturing - make sure that the file format\n"
"you wish to use is supported on your system\n", rcc);
}
if (RT_SUCCESS(rrc) && rcc == S_OK)
{
Log2(("VBoxHeadless: Registering framebuffer\n"));
pFramebuffer->AddRef();
display->SetFramebuffer(VBOX_VIDEO_PRIMARY_SCREEN, pFramebuffer);
}
if (!RT_SUCCESS(rrc) || rcc != S_OK)
rc = E_FAIL;
}
if (rc != S_OK)
{
break;
}
#endif /* defined(VBOX_FFMPEG) */
#ifdef VBOX_WITH_VNC
if (fVNCEnable)
{
Bstr machineName;
machine->COMGETTER(Name)(machineName.asOutParam());
g_pFramebufferVNC = new VNCFB(console, uVNCPort, pszVNCPassword);
rc = g_pFramebufferVNC->init(machineName.raw() ? Utf8Str(machineName.raw()).c_str() : "");
if (rc != S_OK)
{
LogError("Failed to load the vnc server extension, possibly due to a damaged file\n", rc);
delete g_pFramebufferVNC;
break;
}
Log2(("VBoxHeadless: Registering VNC framebuffer\n"));
g_pFramebufferVNC->AddRef();
display->SetFramebuffer(VBOX_VIDEO_PRIMARY_SCREEN, g_pFramebufferVNC);
}
if (rc != S_OK)
break;
#endif
ULONG cMonitors = 1;
machine->COMGETTER(MonitorCount)(&cMonitors);
unsigned uScreenId;
for (uScreenId = 0; uScreenId < cMonitors; uScreenId++)
{
# ifdef VBOX_FFMPEG
if (fFFMPEG && uScreenId == 0)
{
/* Already registered. */
continue;
}
# endif
# ifdef VBOX_WITH_VNC
if (fVNCEnable && uScreenId == 0)
{
/* Already registered. */
continue;
}
# endif
VRDPFramebuffer *pVRDPFramebuffer = new VRDPFramebuffer();
if (!pVRDPFramebuffer)
{
RTPrintf("Error: could not create framebuffer object %d\n", uScreenId);
break;
}
pVRDPFramebuffer->AddRef();
display->SetFramebuffer(uScreenId, pVRDPFramebuffer);
}
if (uScreenId < cMonitors)
{
break;
}
// fill in remaining slots with null framebuffers
for (uScreenId = 0; uScreenId < cMonitors; uScreenId++)
{
ComPtr<IFramebuffer> fb;
LONG xOrigin, yOrigin;
HRESULT hrc2 = display->GetFramebuffer(uScreenId,
fb.asOutParam(),
&xOrigin, &yOrigin);
if (hrc2 == S_OK && fb.isNull())
{
NullFB *pNullFB = new NullFB();
pNullFB->AddRef();
pNullFB->init();
display->SetFramebuffer(uScreenId, pNullFB);
}
}
/* get the machine debugger (isn't necessarily available) */
ComPtr <IMachineDebugger> machineDebugger;
console->COMGETTER(Debugger)(machineDebugger.asOutParam());
if (machineDebugger)
{
Log(("Machine debugger available!\n"));
}
if (fRawR0 != ~0U)
{
if (!machineDebugger)
{
RTPrintf("Error: No debugger object; -%srawr0 cannot be executed!\n", fRawR0 ? "" : "no");
break;
}
machineDebugger->COMSETTER(RecompileSupervisor)(!fRawR0);
}
if (fRawR3 != ~0U)
{
if (!machineDebugger)
{
RTPrintf("Error: No debugger object; -%srawr3 cannot be executed!\n", fRawR3 ? "" : "no");
break;
}
machineDebugger->COMSETTER(RecompileUser)(!fRawR3);
}
if (fPATM != ~0U)
{
if (!machineDebugger)
{
RTPrintf("Error: No debugger object; -%spatm cannot be executed!\n", fPATM ? "" : "no");
break;
}
machineDebugger->COMSETTER(PATMEnabled)(fPATM);
}
if (fCSAM != ~0U)
{
if (!machineDebugger)
{
RTPrintf("Error: No debugger object; -%scsam cannot be executed!\n", fCSAM ? "" : "no");
break;
}
machineDebugger->COMSETTER(CSAMEnabled)(fCSAM);
}
/* initialize global references */
gConsole = console;
gEventQ = com::EventQueue::getMainEventQueue();
/* VirtualBoxClient events registration. */
{
ComPtr<IEventSource> pES;
CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
ComObjPtr<VirtualBoxClientEventListenerImpl> listener;
listener.createObject();
listener->init(new VirtualBoxClientEventListener());
vboxClientListener = listener;
com::SafeArray<VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged);
CHECK_ERROR(pES, RegisterListener(vboxClientListener, ComSafeArrayAsInParam(eventTypes), true));
}
/* Console events registration. */
{
ComPtr<IEventSource> es;
CHECK_ERROR(console, COMGETTER(EventSource)(es.asOutParam()));
consoleListener.createObject();
consoleListener->init(new ConsoleEventListener());
com::SafeArray<VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnMouseCapabilityChanged);
eventTypes.push_back(VBoxEventType_OnStateChanged);
eventTypes.push_back(VBoxEventType_OnVRDEServerInfoChanged);
eventTypes.push_back(VBoxEventType_OnCanShowWindow);
eventTypes.push_back(VBoxEventType_OnShowWindow);
CHECK_ERROR(es, RegisterListener(consoleListener, ComSafeArrayAsInParam(eventTypes), true));
}
/* default is to enable the remote desktop server (backward compatibility) */
BOOL fVRDEEnable = true;
BOOL fVRDEEnabled;
ComPtr <IVRDEServer> vrdeServer;
CHECK_ERROR_BREAK(machine, COMGETTER(VRDEServer)(vrdeServer.asOutParam()));
CHECK_ERROR_BREAK(vrdeServer, COMGETTER(Enabled)(&fVRDEEnabled));
if (vrdeEnabled != NULL)
{
/* -vrdeServer on|off|config */
if (!strcmp(vrdeEnabled, "off") || !strcmp(vrdeEnabled, "disable"))
fVRDEEnable = false;
else if (!strcmp(vrdeEnabled, "config"))
{
if (!fVRDEEnabled)
fVRDEEnable = false;
}
else if (strcmp(vrdeEnabled, "on") && strcmp(vrdeEnabled, "enable"))
{
RTPrintf("-vrdeServer requires an argument (on|off|config)\n");
break;
}
}
if (fVRDEEnable)
{
Log(("VBoxHeadless: Enabling VRDE server...\n"));
/* set VRDE port if requested by the user */
if (vrdePort != NULL)
{
Bstr bstr = vrdePort;
CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.raw()));
}
/* set VRDE address if requested by the user */
if (vrdeAddress != NULL)
{
CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(vrdeAddress).raw()));
}
/* Set VRDE properties. */
if (cVRDEProperties > 0)
{
for (unsigned i = 0; i < cVRDEProperties; i++)
{
/* Parse 'name=value' */
char *pszProperty = RTStrDup(aVRDEProperties[i]);
if (pszProperty)
{
char *pDelimiter = strchr(pszProperty, '=');
if (pDelimiter)
{
*pDelimiter = '\0';
Bstr bstrName = pszProperty;
Bstr bstrValue = &pDelimiter[1];
CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
}
else
{
RTPrintf("Error: Invalid VRDE property '%s'\n", aVRDEProperties[i]);
RTStrFree(pszProperty);
rc = E_INVALIDARG;
break;
}
RTStrFree(pszProperty);
}
else
{
RTPrintf("Error: Failed to allocate memory for VRDE property '%s'\n", aVRDEProperties[i]);
rc = E_OUTOFMEMORY;
break;
}
}
if (FAILED(rc))
break;
}
/* enable VRDE server (only if currently disabled) */
if (!fVRDEEnabled)
{
CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(TRUE));
}
}
else
{
/* disable VRDE server (only if currently enabled */
if (fVRDEEnabled)
{
CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(FALSE));
}
}
/* Disable the host clipboard before powering up */
console->COMSETTER(UseHostClipboard)(false);
Log(("VBoxHeadless: Powering up the machine...\n"));
ComPtr <IProgress> progress;
CHECK_ERROR_BREAK(console, PowerUp(progress.asOutParam()));
/*
* Wait for the result because there can be errors.
*
* It's vital to process events while waiting (teleportation deadlocks),
* so we'll poll for the completion instead of waiting on it.
*/
for (;;)
{
BOOL fCompleted;
rc = progress->COMGETTER(Completed)(&fCompleted);
if (FAILED(rc) || fCompleted)
break;
/* Process pending events, then wait for new ones. Note, this
* processes NULL events signalling event loop termination. */
gEventQ->processEventQueue(0);
if (!g_fTerminateFE)
gEventQ->processEventQueue(500);
}
if (SUCCEEDED(progress->WaitForCompletion(-1)))
{
/* Figure out if the operation completed with a failed status
* and print the error message. Terminate immediately, and let
* the cleanup code take care of potentially pending events. */
LONG progressRc;
progress->COMGETTER(ResultCode)(&progressRc);
rc = progressRc;
if (FAILED(rc))
{
com::ProgressErrorInfo info(progress);
if (info.isBasicAvailable())
{
RTPrintf("Error: failed to start machine. Error message: %lS\n", info.getText().raw());
}
else
{
RTPrintf("Error: failed to start machine. No error message available!\n");
}
break;
}
}
/* VirtualBox events registration. */
{
ComPtr<IEventSource> es;
CHECK_ERROR(virtualBox, COMGETTER(EventSource)(es.asOutParam()));
ComObjPtr<VirtualBoxEventListenerImpl> listener;
listener.createObject();
listener->init(new VirtualBoxEventListener());
vboxListener = listener;
com::SafeArray<VBoxEventType_T> eventTypes;
eventTypes.push_back(VBoxEventType_OnGuestPropertyChanged);
CHECK_ERROR(es, RegisterListener(vboxListener, ComSafeArrayAsInParam(eventTypes), true));
}
#ifdef VBOX_WITH_SAVESTATE_ON_SIGNAL
signal(SIGINT, SaveState);
signal(SIGTERM, SaveState);
#endif
Log(("VBoxHeadless: Waiting for PowerDown...\n"));
while ( !g_fTerminateFE
&& RT_SUCCESS(gEventQ->processEventQueue(RT_INDEFINITE_WAIT)))
/* nothing */ ;
Log(("VBoxHeadless: event loop has terminated...\n"));
#ifdef VBOX_FFMPEG
if (pFramebuffer)
{
pFramebuffer->Release();
Log(("Released framebuffer\n"));
pFramebuffer = NULL;
}
#endif /* defined(VBOX_FFMPEG) */
/* we don't have to disable VRDE here because we don't save the settings of the VM */
}
while (0);
/*
* Get the machine state.
*/
MachineState_T machineState = MachineState_Aborted;
if (!machine.isNull())
machine->COMGETTER(State)(&machineState);
/*
* Turn off the VM if it's running
*/
if ( gConsole
&& ( machineState == MachineState_Running
|| machineState == MachineState_Teleporting
|| machineState == MachineState_LiveSnapshotting
/** @todo power off paused VMs too? */
)
)
do
{
consoleListener->getWrapped()->ignorePowerOffEvents(true);
ComPtr<IProgress> pProgress;
CHECK_ERROR_BREAK(gConsole, PowerDown(pProgress.asOutParam()));
CHECK_ERROR_BREAK(pProgress, WaitForCompletion(-1));
BOOL completed;
CHECK_ERROR_BREAK(pProgress, COMGETTER(Completed)(&completed));
ASSERT(completed);
LONG hrc;
CHECK_ERROR_BREAK(pProgress, COMGETTER(ResultCode)(&hrc));
if (FAILED(hrc))
{
RTPrintf("VBoxHeadless: ERROR: Failed to power down VM!");
com::ErrorInfo info;
if (!info.isFullAvailable() && !info.isBasicAvailable())
com::GluePrintRCMessage(hrc);
else
GluePrintErrorInfo(info);
break;
}
} while (0);
/* VirtualBox callback unregistration. */
if (vboxListener)
{
ComPtr<IEventSource> es;
CHECK_ERROR(virtualBox, COMGETTER(EventSource)(es.asOutParam()));
if (!es.isNull())
CHECK_ERROR(es, UnregisterListener(vboxListener));
vboxListener.setNull();
}
/* Console callback unregistration. */
if (consoleListener)
{
ComPtr<IEventSource> es;
CHECK_ERROR(gConsole, COMGETTER(EventSource)(es.asOutParam()));
if (!es.isNull())
CHECK_ERROR(es, UnregisterListener(consoleListener));
consoleListener.setNull();
}
/* VirtualBoxClient callback unregistration. */
if (vboxClientListener)
{
ComPtr<IEventSource> pES;
CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
if (!pES.isNull())
CHECK_ERROR(pES, UnregisterListener(vboxClientListener));
vboxClientListener.setNull();
}
/* No more access to the 'console' object, which will be uninitialized by the next session->Close call. */
gConsole = NULL;
if (fSessionOpened)
{
/*
* Close the session. This will also uninitialize the console and
* unregister the callback we've registered before.
*/
Log(("VBoxHeadless: Closing the session...\n"));
session->UnlockMachine();
}
/* Must be before com::Shutdown */
session.setNull();
virtualBox.setNull();
pVirtualBoxClient.setNull();
machine.setNull();
com::Shutdown();
LogFlow(("VBoxHeadless FINISHED.\n"));
return FAILED(rc) ? 1 : 0;
}
static void vboxSolarisAddHostIface(char *pszIface, int Instance, void *pvHostNetworkInterfaceList)
{
std::list<ComObjPtr<HostNetworkInterface> > *pList = (std::list<ComObjPtr<HostNetworkInterface> > *)pvHostNetworkInterfaceList;
Assert(pList);
typedef std::map <std::string, std::string> NICMap;
typedef std::pair <std::string, std::string> NICPair;
static NICMap SolarisNICMap;
if (SolarisNICMap.empty())
{
SolarisNICMap.insert(NICPair("afe", "ADMtek Centaur/Comet Fast Ethernet"));
SolarisNICMap.insert(NICPair("atge", "Atheros/Attansic Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("aggr", "Link Aggregation Interface"));
SolarisNICMap.insert(NICPair("bfe", "Broadcom BCM4401 Fast Ethernet"));
SolarisNICMap.insert(NICPair("bge", "Broadcom BCM57xx Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("bnx", "Broadcom NetXtreme Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("bnxe", "Broadcom NetXtreme II 10 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("ce", "Cassini Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("chxge", "Chelsio Ethernet"));
SolarisNICMap.insert(NICPair("dmfe", "Davicom 9102 Fast Ethernet"));
SolarisNICMap.insert(NICPair("dnet", "DEC 21040/41 21140 Ethernet"));
SolarisNICMap.insert(NICPair("e1000", "Intel PRO/1000 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("e1000g", "Intel PRO/1000 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("elx", "3COM Etherlink III Ethernet"));
SolarisNICMap.insert(NICPair("elxl", "3COM Etherlink XL Ethernet"));
SolarisNICMap.insert(NICPair("eri", "eri Fast Ethernet"));
SolarisNICMap.insert(NICPair("ge", "GEM Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("hme", "SUNW,hme Fast-Ethernet"));
SolarisNICMap.insert(NICPair("hxge", "Sun Blade 10 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("igb", "Intel 82575 PCI-E Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("ipge", "PCI-E Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("iprb", "Intel 82557/58/59 Ethernet"));
SolarisNICMap.insert(NICPair("ixgb", "Intel 82597ex 10 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("ixgbe", "Intel 10 Gigabit PCI-E Ethernet"));
SolarisNICMap.insert(NICPair("mcxe", "Mellanox ConnectX-2 10 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("mxfe", "Macronix 98715 Fast Ethernet"));
SolarisNICMap.insert(NICPair("nfo", "Nvidia Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("nge", "Nvidia Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("ntxn", "NetXen 10/1 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("nxge", "Sun 10/1 Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("pcelx", "3COM EtherLink III PCMCIA Ethernet"));
SolarisNICMap.insert(NICPair("pcn", "AMD PCnet Ethernet"));
SolarisNICMap.insert(NICPair("qfe", "SUNW,qfe Quad Fast-Ethernet"));
SolarisNICMap.insert(NICPair("rge", "Realtek Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("rtls", "Realtek 8139 Fast Ethernet"));
SolarisNICMap.insert(NICPair("sfe", "SiS900 Fast Ethernet"));
SolarisNICMap.insert(NICPair("skge", "SksKonnect Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("spwr", "SMC EtherPower II 10/100 (9432) Ethernet"));
SolarisNICMap.insert(NICPair("vboxnet", "VirtualBox Host Ethernet"));
SolarisNICMap.insert(NICPair("vboxvnic_template", "VirtualBox Virtual Network Interface Template"));
SolarisNICMap.insert(NICPair("vlan", "Virtual LAN Ethernet"));
SolarisNICMap.insert(NICPair("vr", "VIA Rhine Fast Ethernet"));
SolarisNICMap.insert(NICPair("vnic", "Virtual Network Interface Ethernet"));
SolarisNICMap.insert(NICPair("xge", "Neterior Xframe 10Gigabit Ethernet"));
SolarisNICMap.insert(NICPair("yge", "Marvell Yukon 2 Fast Ethernet"));
}
/*
* Try picking up description from our NIC map.
*/
char szNICInstance[128];
RTStrPrintf(szNICInstance, sizeof(szNICInstance), "%s%d", pszIface, Instance);
char szNICDesc[256];
std::string Description = SolarisNICMap[pszIface];
if (Description != "VirtualBox Host Ethernet")
{
if (Description != "")
RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - %s", szNICInstance, Description.c_str());
else
RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s - Ethernet", szNICInstance);
}
else
RTStrPrintf(szNICDesc, sizeof(szNICDesc), "%s", szNICInstance);
/*
* Try to get IP V4 address and netmask as well as Ethernet address.
*/
NETIFINFO Info;
memset(&Info, 0, sizeof(Info));
int Sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (Sock > 0)
{
struct lifreq IfReq;
strcpy(IfReq.lifr_name, szNICInstance);
if (ioctl(Sock, SIOCGLIFADDR, &IfReq) >= 0)
{
memcpy(Info.IPAddress.au8, &((struct sockaddr_in *)&IfReq.lifr_addr)->sin_addr.s_addr,
sizeof(Info.IPAddress.au8));
struct arpreq ArpReq;
memcpy(&ArpReq.arp_pa, &IfReq.lifr_addr, sizeof(struct sockaddr_in));
/*
* We might fail if the interface has not been assigned an IP address.
* That doesn't matter; as long as it's plumbed we can pick it up.
* But, if it has not acquired an IP address we cannot obtain it's MAC
* address this way, so we just use all zeros there.
*/
if (ioctl(Sock, SIOCGARP, &ArpReq) >= 0)
{
memcpy(&Info.MACAddress, ArpReq.arp_ha.sa_data, sizeof(Info.MACAddress));
}
}
if (ioctl(Sock, SIOCGLIFNETMASK, &IfReq) >= 0)
{
memcpy(Info.IPNetMask.au8, &((struct sockaddr_in *)&IfReq.lifr_addr)->sin_addr.s_addr,
sizeof(Info.IPNetMask.au8));
}
if (ioctl(Sock, SIOCGLIFFLAGS, &IfReq) >= 0)
{
Info.enmStatus = IfReq.lifr_flags & IFF_UP ? NETIF_S_UP : NETIF_S_DOWN;
}
close(Sock);
}
/*
* Try to get IP V6 address and netmask.
*/
Sock = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
if (Sock > 0)
{
struct lifreq IfReq;
strcpy(IfReq.lifr_name, szNICInstance);
if (ioctl(Sock, SIOCGLIFADDR, &IfReq) >= 0)
{
memcpy(Info.IPv6Address.au8, ((struct sockaddr_in6 *)&IfReq.lifr_addr)->sin6_addr.s6_addr,
sizeof(Info.IPv6Address.au8));
}
if (ioctl(Sock, SIOCGLIFNETMASK, &IfReq) >= 0)
{
memcpy(Info.IPv6NetMask.au8, ((struct sockaddr_in6 *)&IfReq.lifr_addr)->sin6_addr.s6_addr,
sizeof(Info.IPv6NetMask.au8));
}
close(Sock);
}
/*
* Construct UUID with interface name and the MAC address if available.
*/
RTUUID Uuid;
RTUuidClear(&Uuid);
memcpy(&Uuid, szNICInstance, RT_MIN(strlen(szNICInstance), sizeof(Uuid)));
Uuid.Gen.u8ClockSeqHiAndReserved = (Uuid.Gen.u8ClockSeqHiAndReserved & 0x3f) | 0x80;
Uuid.Gen.u16TimeHiAndVersion = (Uuid.Gen.u16TimeHiAndVersion & 0x0fff) | 0x4000;
Uuid.Gen.au8Node[0] = Info.MACAddress.au8[0];
Uuid.Gen.au8Node[1] = Info.MACAddress.au8[1];
Uuid.Gen.au8Node[2] = Info.MACAddress.au8[2];
Uuid.Gen.au8Node[3] = Info.MACAddress.au8[3];
Uuid.Gen.au8Node[4] = Info.MACAddress.au8[4];
Uuid.Gen.au8Node[5] = Info.MACAddress.au8[5];
Info.Uuid = Uuid;
Info.enmMediumType = NETIF_T_ETHERNET;
strncpy(Info.szShortName, szNICInstance, sizeof(Info.szShortName) - 1);
HostNetworkInterfaceType_T enmType;
if (strncmp("vboxnet", szNICInstance, 7))
enmType = HostNetworkInterfaceType_Bridged;
else
enmType = HostNetworkInterfaceType_HostOnly;
queryIfaceSpeed(&Info);
ComObjPtr<HostNetworkInterface> IfObj;
IfObj.createObject();
if (SUCCEEDED(IfObj->init(Bstr(szNICDesc), enmType, &Info)))
pList->push_back(IfObj);
}
void UIConsoleEventHandler::prepare()
{
/* Make sure session is passed: */
AssertPtrReturnVoid(m_pSession);
/* Create Main-event listener instance: */
ComObjPtr<UIMainEventListenerImpl> pListener;
pListener.createObject();
pListener->init(new UIMainEventListener, this);
m_mainEventListener = CEventListener(pListener);
/* Get console: */
const CConsole console = m_pSession->session().GetConsole();
AssertReturnVoid(!console.isNull() && console.isOk());
/* Get event-source: */
CEventSource eventSource = console.GetEventSource();
AssertReturnVoid(!eventSource.isNull() && eventSource.isOk());
/* Register listener for expected event-types: */
QVector<KVBoxEventType> events;
events
<< KVBoxEventType_OnMousePointerShapeChanged
<< KVBoxEventType_OnMouseCapabilityChanged
<< KVBoxEventType_OnKeyboardLedsChanged
<< KVBoxEventType_OnStateChanged
<< KVBoxEventType_OnAdditionsStateChanged
<< KVBoxEventType_OnNetworkAdapterChanged
<< KVBoxEventType_OnMediumChanged
<< KVBoxEventType_OnVRDEServerChanged
<< KVBoxEventType_OnVRDEServerInfoChanged
<< KVBoxEventType_OnVideoCaptureChanged
<< KVBoxEventType_OnUSBControllerChanged
<< KVBoxEventType_OnUSBDeviceStateChanged
<< KVBoxEventType_OnSharedFolderChanged
<< KVBoxEventType_OnCPUExecutionCapChanged
<< KVBoxEventType_OnGuestMonitorChanged
<< KVBoxEventType_OnRuntimeError
<< KVBoxEventType_OnCanShowWindow
<< KVBoxEventType_OnShowWindow;
eventSource.RegisterListener(m_mainEventListener, events, TRUE);
/* Prepare connections: */
connect(pListener->getWrapped(), SIGNAL(sigMousePointerShapeChange(bool, bool, QPoint, QSize, QVector<uint8_t>)),
this, SIGNAL(sigMousePointerShapeChange(bool, bool, QPoint, QSize, QVector<uint8_t>)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigMouseCapabilityChange(bool, bool, bool, bool)),
this, SIGNAL(sigMouseCapabilityChange(bool, bool, bool, bool)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigKeyboardLedsChangeEvent(bool, bool, bool)),
this, SIGNAL(sigKeyboardLedsChangeEvent(bool, bool, bool)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigStateChange(KMachineState)),
this, SIGNAL(sigStateChange(KMachineState)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigAdditionsChange()),
this, SIGNAL(sigAdditionsChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigNetworkAdapterChange(CNetworkAdapter)),
this, SIGNAL(sigNetworkAdapterChange(CNetworkAdapter)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigMediumChange(CMediumAttachment)),
this, SIGNAL(sigMediumChange(CMediumAttachment)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigVRDEChange()),
this, SIGNAL(sigVRDEChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigVideoCaptureChange()),
this, SIGNAL(sigVideoCaptureChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigUSBControllerChange()),
this, SIGNAL(sigUSBControllerChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigUSBDeviceStateChange(CUSBDevice, bool, CVirtualBoxErrorInfo)),
this, SIGNAL(sigUSBDeviceStateChange(CUSBDevice, bool, CVirtualBoxErrorInfo)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigSharedFolderChange()),
this, SIGNAL(sigSharedFolderChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigCPUExecutionCapChange()),
this, SIGNAL(sigCPUExecutionCapChange()),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
this, SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
Qt::QueuedConnection);
connect(pListener->getWrapped(), SIGNAL(sigRuntimeError(bool, QString, QString)),
this, SIGNAL(sigRuntimeError(bool, QString, QString)),
Qt::QueuedConnection);
/* This is a vetoable event, so we have to respond to the event and have to
* use a direct connection therefor. */
connect(pListener->getWrapped(), SIGNAL(sigCanShowWindow(bool&, QString&)),
this, SLOT(sltCanShowWindow(bool&, QString&)),
Qt::DirectConnection);
/* This returns a winId, so we have to respond to the event and have to use
* a direct connection therefor. */
connect(pListener->getWrapped(), SIGNAL(sigShowWindow(LONG64&)),
this, SLOT(sltShowWindow(LONG64&)),
Qt::DirectConnection);
}
