/**
* Put all child nodes of the given expression AST node onto the given to free list.
*
* @returns nothing.
* @param pList The free list to append everything to.
* @param pAstNode The expression node to free.
*/
static void vdScriptAStNodeExpressionPutOnFreeList(PRTLISTANCHOR pList, PVDSCRIPTASTCORE pAstNode)
{
AssertMsgReturnVoid(pAstNode->enmClass == VDSCRIPTASTCLASS_EXPRESSION,
("Given AST node is not a statement\n"));
PVDSCRIPTASTEXPR pExpr = (PVDSCRIPTASTEXPR)pAstNode;
switch (pExpr->enmType)
{
case VDSCRIPTEXPRTYPE_PRIMARY_NUMCONST:
case VDSCRIPTEXPRTYPE_PRIMARY_STRINGCONST:
case VDSCRIPTEXPRTYPE_PRIMARY_IDENTIFIER:
case VDSCRIPTEXPRTYPE_ASSIGNMENT_LIST:
case VDSCRIPTEXPRTYPE_POSTFIX_INCREMENT:
case VDSCRIPTEXPRTYPE_POSTFIX_DECREMENT:
case VDSCRIPTEXPRTYPE_POSTFIX_FNCALL:
case VDSCRIPTEXPRTYPE_UNARY_INCREMENT:
case VDSCRIPTEXPRTYPE_UNARY_DECREMENT:
case VDSCRIPTEXPRTYPE_UNARY_POSSIGN:
case VDSCRIPTEXPRTYPE_UNARY_NEGSIGN:
case VDSCRIPTEXPRTYPE_UNARY_INVERT:
case VDSCRIPTEXPRTYPE_UNARY_NEGATE:
case VDSCRIPTEXPRTYPE_MULTIPLICATION:
case VDSCRIPTEXPRTYPE_DIVISION:
case VDSCRIPTEXPRTYPE_MODULUS:
case VDSCRIPTEXPRTYPE_ADDITION:
case VDSCRIPTEXPRTYPE_SUBTRACTION:
case VDSCRIPTEXPRTYPE_LSR:
case VDSCRIPTEXPRTYPE_LSL:
case VDSCRIPTEXPRTYPE_LOWER:
case VDSCRIPTEXPRTYPE_HIGHER:
case VDSCRIPTEXPRTYPE_LOWEREQUAL:
case VDSCRIPTEXPRTYPE_HIGHEREQUAL:
case VDSCRIPTEXPRTYPE_EQUAL:
case VDSCRIPTEXPRTYPE_NOTEQUAL:
case VDSCRIPTEXPRTYPE_BITWISE_AND:
case VDSCRIPTEXPRTYPE_BITWISE_XOR:
case VDSCRIPTEXPRTYPE_BITWISE_OR:
case VDSCRIPTEXPRTYPE_LOGICAL_AND:
case VDSCRIPTEXPRTYPE_LOGICAL_OR:
case VDSCRIPTEXPRTYPE_ASSIGN:
case VDSCRIPTEXPRTYPE_ASSIGN_MULT:
case VDSCRIPTEXPRTYPE_ASSIGN_DIV:
case VDSCRIPTEXPRTYPE_ASSIGN_MOD:
case VDSCRIPTEXPRTYPE_ASSIGN_ADD:
case VDSCRIPTEXPRTYPE_ASSIGN_SUB:
case VDSCRIPTEXPRTYPE_ASSIGN_LSL:
case VDSCRIPTEXPRTYPE_ASSIGN_LSR:
case VDSCRIPTEXPRTYPE_ASSIGN_AND:
case VDSCRIPTEXPRTYPE_ASSIGN_XOR:
case VDSCRIPTEXPRTYPE_ASSIGN_OR:
case VDSCRIPTEXPRTYPE_INVALID:
default:
AssertMsgFailedReturnVoid(("Invalid AST node expression type %d\n",
pExpr->enmType));
}
}
/**
* Destroys the current scope.
*
* @returns nothing.
* @param pThis The interpreter context.
*/
static void vdScriptInterpreterScopeDestroyCurr(PVDSCRIPTINTERPCTX pThis)
{
AssertMsgReturnVoid(pThis->pFnCallCurr->pScopeCurr != &pThis->pFnCallCurr->ScopeRoot,
("Current scope is root scope of function call\n"));
PVDSCRIPTINTERPSCOPE pScope = pThis->pFnCallCurr->pScopeCurr;
pThis->pFnCallCurr->pScopeCurr = pScope->pParent;
RTStrSpaceDestroy(&pScope->hStrSpaceVar, vdScriptInterpreterVarSpaceDestroy, NULL);
RTMemFree(pScope);
}
/**
* Updates the cached keyboard data.
*
* @todo The current implementation is very brute force...
* Rewrite it so that it doesn't flush the cache completely but simply checks whether
* anything has changed in the HID config. With any luck, there might even be a callback
* or something we can poll for HID config changes...
* setRemovalCallback() is a start...
*/
static void darwinHIDKeyboardCacheDoUpdate(void)
{
g_u64KeyboardTS = RTTimeMilliTS();
/*
* Dispense with the old cache data.
*/
darwinHIDKeyboardCacheZap();
/*
* Open the master port on the first invocation.
*/
if (!g_MasterPort)
{
kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &g_MasterPort);
AssertReturnVoid(krc == KERN_SUCCESS);
}
/*
* Create a matching dictionary for searching for keyboards devices.
*/
static const UInt32 s_Page = kHIDPage_GenericDesktop;
static const UInt32 s_Usage = kHIDUsage_GD_Keyboard;
CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOHIDDeviceKey);
AssertReturnVoid(RefMatchingDict);
CFDictionarySetValue(RefMatchingDict, CFSTR(kIOHIDPrimaryUsagePageKey),
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &s_Page));
CFDictionarySetValue(RefMatchingDict, CFSTR(kIOHIDPrimaryUsageKey),
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &s_Usage));
/*
* Perform the search and get a collection of keyboard devices.
*/
io_iterator_t Keyboards = NULL;
IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &Keyboards);
AssertMsgReturnVoid(rc == kIOReturnSuccess, ("rc=%d\n", rc));
RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
/*
* Enumerate the keyboards and query the cache data.
*/
unsigned i = 0;
io_object_t KeyboardDevice;
while ( i < RT_ELEMENTS(g_aKeyboards)
&& (KeyboardDevice = IOIteratorNext(Keyboards)) != 0)
{
if (darwinHIDKeyboardCacheCreateEntry(&g_aKeyboards[i], KeyboardDevice))
i++;
IOObjectRelease(KeyboardDevice);
}
g_cKeyboards = i;
IOObjectRelease(Keyboards);
}
void UIGDetailsElement::sltMountStorageMedium()
{
/* Sender action: */
QAction *pAction = qobject_cast<QAction*>(sender());
AssertMsgReturnVoid(pAction, ("This slot should only be called by menu action!\n"));
/* Current mount-target: */
const UIMediumTarget target = pAction->data().value<UIMediumTarget>();
/* Update current machine mount-target: */
vboxGlobal().updateMachineStorage(machine(), target);
}
/**
* Hook function for the thread-free event.
*
* @param pvThreadCtxInt Opaque pointer to the internal thread-context
* object.
* @param fIsExec Whether this event is triggered due to exec().
*/
static void rtThreadCtxHooksSolFree(void *pvThreadCtxInt, int fIsExec)
{
PRTTHREADCTXINT pThis = (PRTTHREADCTXINT)pvThreadCtxInt;
AssertPtrReturnVoid(pThis);
AssertMsgReturnVoid(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis));
uint32_t cRefs = ASMAtomicReadU32(&pThis->cRefs);
if (RT_UNLIKELY(!cRefs))
{
/* Should never happen. */
AssertMsgFailed(("rtThreadCtxHooksSolFree with cRefs=0 pThis=%p\n", pThis));
return;
}
cRefs = ASMAtomicDecU32(&pThis->cRefs);
if (!cRefs)
{
Assert(!pThis->fRegistered);
ASMAtomicWriteU32(&pThis->u32Magic, ~RTTHREADCTXINT_MAGIC);
RTMemFree(pThis);
}
}
/**
* Dispatches an interrupt that arrived while we were in the guest context.
*
* @param pVM The VM handle.
* @remark Must be called with interrupts disabled.
*/
VMMR0DECL(void) TRPMR0DispatchHostInterrupt(PVM pVM)
{
/*
* Get the active interrupt vector number.
*/
PVMCPU pVCpu = VMMGetCpu0(pVM);
RTUINT uActiveVector = pVCpu->trpm.s.uActiveVector;
pVCpu->trpm.s.uActiveVector = ~0;
AssertMsgReturnVoid(uActiveVector < 256, ("uActiveVector=%#x is invalid! (More assertions to come, please enjoy!)\n", uActiveVector));
#if HC_ARCH_BITS == 64 && defined(RT_OS_DARWIN)
/*
* Do it the simple and safe way.
*
* This is a workaround for an optimization bug in the code below
* or a gcc 4.2 on mac (snow leopard seed 314).
*/
trpmR0DispatchHostInterruptSimple(uActiveVector);
#else /* The complicated way: */
# ifdef VBOX_WITH_HYBRID_32BIT_KERNEL
/*
* Check if we're in long mode or not.
*/
if ( (ASMCpuId_EDX(0x80000001) & X86_CPUID_AMD_FEATURE_EDX_LONG_MODE)
&& (ASMRdMsr(MSR_K6_EFER) & MSR_K6_EFER_LMA))
{
trpmR0DispatchHostInterruptSimple(uActiveVector);
return;
}
# endif
/*
* Get the handler pointer (16:32 ptr) / (16:48 ptr).
*/
RTIDTR Idtr;
ASMGetIDTR(&Idtr);
# if HC_ARCH_BITS == 32
PVBOXIDTE pIdte = &((PVBOXIDTE)Idtr.pIdt)[uActiveVector];
# else
PVBOXIDTE64 pIdte = &((PVBOXIDTE64)Idtr.pIdt)[uActiveVector];
# endif
AssertMsgReturnVoid(pIdte->Gen.u1Present, ("The IDT entry (%d) is not present!\n", uActiveVector));
AssertMsgReturnVoid( pIdte->Gen.u3Type1 == VBOX_IDTE_TYPE1
|| pIdte->Gen.u5Type2 == VBOX_IDTE_TYPE2_INT_32,
("The IDT entry (%d) is not 32-bit int gate! type1=%#x type2=%#x\n",
uActiveVector, pIdte->Gen.u3Type1, pIdte->Gen.u5Type2));
# if HC_ARCH_BITS == 32
RTFAR32 pfnHandler;
pfnHandler.off = VBOXIDTE_OFFSET(*pIdte);
pfnHandler.sel = pIdte->Gen.u16SegSel;
const RTR0UINTREG uRSP = ~(RTR0UINTREG)0;
# else /* 64-bit: */
RTFAR64 pfnHandler;
pfnHandler.off = VBOXIDTE64_OFFSET(*pIdte);
pfnHandler.sel = pIdte->Gen.u16SegSel;
const RTR0UINTREG uRSP = ~(RTR0UINTREG)0;
if (pIdte->Gen.u3Ist)
{
trpmR0DispatchHostInterruptSimple(uActiveVector);
return;
}
# endif
/*
* Dispatch it.
*/
trpmR0DispatchHostInterrupt(pfnHandler.off, pfnHandler.sel, uRSP);
#endif
}
/**
* Free a given statement AST node and put everything on the given to free list.
*
* @returns nothing.
* @param pList The free list to append everything to.
* @param pAstNode The statement node to free.
*/
static void vdScriptAstNodeStatmentPutOnFreeList(PRTLISTANCHOR pList, PVDSCRIPTASTCORE pAstNode)
{
AssertMsgReturnVoid(pAstNode->enmClass == VDSCRIPTASTCLASS_STATEMENT,
("Given AST node is not a statement\n"));
PVDSCRIPTASTSTMT pStmt = (PVDSCRIPTASTSTMT)pAstNode;
switch (pStmt->enmStmtType)
{
case VDSCRIPTSTMTTYPE_COMPOUND:
{
/* Put all declarations on the to free list. */
while (!RTListIsEmpty(&pStmt->Compound.ListDecls))
{
PVDSCRIPTASTCORE pNode = RTListGetFirst(&pStmt->Compound.ListDecls, VDSCRIPTASTCORE, ListNode);
RTListNodeRemove(&pNode->ListNode);
RTListAppend(pList, &pNode->ListNode);
}
/* Put all statements on the to free list. */
while (!RTListIsEmpty(&pStmt->Compound.ListStmts))
{
PVDSCRIPTASTCORE pNode = RTListGetFirst(&pStmt->Compound.ListDecls, VDSCRIPTASTCORE, ListNode);
RTListNodeRemove(&pNode->ListNode);
RTListAppend(pList, &pNode->ListNode);
}
break;
}
case VDSCRIPTSTMTTYPE_EXPRESSION:
{
RTListAppend(pList, &pStmt->pExpr->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_IF:
{
RTListAppend(pList, &pStmt->If.pCond->Core.ListNode);
RTListAppend(pList, &pStmt->If.pTrueStmt->Core.ListNode);
if (pStmt->If.pElseStmt)
RTListAppend(pList, &pStmt->If.pElseStmt->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_SWITCH:
{
RTListAppend(pList, &pStmt->Switch.pCond->Core.ListNode);
RTListAppend(pList, &pStmt->Switch.pStmt->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_WHILE:
{
RTListAppend(pList, &pStmt->While.pCond->Core.ListNode);
RTListAppend(pList, &pStmt->While.pStmt->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_FOR:
{
RTListAppend(pList, &pStmt->For.pExprStart->Core.ListNode);
RTListAppend(pList, &pStmt->For.pExprCond->Core.ListNode);
RTListAppend(pList, &pStmt->For.pExpr3->Core.ListNode);
RTListAppend(pList, &pStmt->For.pStmt->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_RETURN:
{
if (pStmt->pExpr)
RTListAppend(pList, &pStmt->pExpr->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_CASE:
{
RTListAppend(pList, &pStmt->Case.pExpr->Core.ListNode);
RTListAppend(pList, &pStmt->Case.pStmt->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_DEFAULT:
{
RTListAppend(pList, &pStmt->Case.pStmt->Core.ListNode);
break;
}
case VDSCRIPTSTMTTYPE_CONTINUE:
case VDSCRIPTSTMTTYPE_BREAK:
break;
case VDSCRIPTSTMTTYPE_INVALID:
default:
AssertMsgFailedReturnVoid(("Invalid AST node statement type %d\n",
pStmt->enmStmtType));
}
}
/**
* Free a memory block.
*
* @param pHeapInt The heap.
* @param pBlock The memory block to free.
*/
static void rtHeapOffsetFreeBlock(PRTHEAPOFFSETINTERNAL pHeapInt, PRTHEAPOFFSETBLOCK pBlock)
{
PRTHEAPOFFSETFREE pFree = (PRTHEAPOFFSETFREE)pBlock;
PRTHEAPOFFSETFREE pLeft;
PRTHEAPOFFSETFREE pRight;
#ifdef RTHEAPOFFSET_STRICT
rtHeapOffsetAssertAll(pHeapInt);
#endif
/*
* Look for the closest free list blocks by walking the blocks right
* of us (both lists are sorted by address).
*/
pLeft = NULL;
pRight = NULL;
if (pHeapInt->offFreeTail)
{
pRight = RTHEAPOFF_TO_PTR_N(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETFREE);
while (pRight && !RTHEAPOFFSETBLOCK_IS_FREE(&pRight->Core))
{
ASSERT_BLOCK(pHeapInt, &pRight->Core);
pRight = RTHEAPOFF_TO_PTR_N(pHeapInt, pRight->Core.offNext, PRTHEAPOFFSETFREE);
}
if (!pRight)
pLeft = RTHEAPOFF_TO_PTR_N(pHeapInt, pHeapInt->offFreeTail, PRTHEAPOFFSETFREE);
else
{
ASSERT_BLOCK_FREE(pHeapInt, pRight);
pLeft = RTHEAPOFF_TO_PTR_N(pHeapInt, pRight->offPrev, PRTHEAPOFFSETFREE);
}
if (pLeft)
ASSERT_BLOCK_FREE(pHeapInt, pLeft);
}
AssertMsgReturnVoid(pLeft != pFree, ("Freed twice! pv=%p (pBlock=%p)\n", pBlock + 1, pBlock));
ASSERT_L(RTHEAPOFF_TO_OFF(pHeapInt, pLeft), RTHEAPOFF_TO_OFF(pHeapInt, pFree));
Assert(!pRight || (uintptr_t)pRight > (uintptr_t)pFree);
Assert(!pLeft || RTHEAPOFF_TO_PTR_N(pHeapInt, pLeft->offNext, PRTHEAPOFFSETFREE) == pRight);
/*
* Insert at the head of the free block list?
*/
if (!pLeft)
{
Assert(pRight == RTHEAPOFF_TO_PTR_N(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE));
pFree->Core.fFlags |= RTHEAPOFFSETBLOCK_FLAGS_FREE;
pFree->offPrev = 0;
pFree->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pRight);
if (pRight)
pRight->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
else
pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
pHeapInt->offFreeHead = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
}
else
{
/*
* Can we merge with left hand free block?
*/
if (pLeft->Core.offNext == RTHEAPOFF_TO_OFF(pHeapInt, pFree))
{
pLeft->Core.offNext = pFree->Core.offNext;
if (pFree->Core.offNext)
RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pLeft);
pHeapInt->cbFree -= pLeft->cb;
pFree = pLeft;
}
/*
* No, just link it into the free list then.
*/
else
{
pFree->Core.fFlags |= RTHEAPOFFSETBLOCK_FLAGS_FREE;
pFree->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pRight);
pFree->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pLeft);
pLeft->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
if (pRight)
pRight->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
else
pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
}
}
/*
* Can we merge with right hand free block?
*/
if ( pRight
&& pRight->Core.offPrev == RTHEAPOFF_TO_OFF(pHeapInt, pFree))
{
/* core */
pFree->Core.offNext = pRight->Core.offNext;
if (pRight->Core.offNext)
RTHEAPOFF_TO_PTR(pHeapInt, pRight->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
/* free */
pFree->offNext = pRight->offNext;
if (pRight->offNext)
RTHEAPOFF_TO_PTR(pHeapInt, pRight->offNext, PRTHEAPOFFSETFREE)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
else
pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
pHeapInt->cbFree -= pRight->cb;
}
/*
* Calculate the size and update free stats.
*/
pFree->cb = (pFree->Core.offNext ? pFree->Core.offNext : pHeapInt->cbHeap)
- RTHEAPOFF_TO_OFF(pHeapInt, pFree) - sizeof(RTHEAPOFFSETBLOCK);
pHeapInt->cbFree += pFree->cb;
ASSERT_BLOCK_FREE(pHeapInt, pFree);
#ifdef RTHEAPOFFSET_STRICT
rtHeapOffsetAssertAll(pHeapInt);
#endif
}
void UIHostNetworkManagerWidget::sltHandleItemChange(QTreeWidgetItem *pItem)
{
/* Get network item: */
UIItemHostNetwork *pChangedItem = static_cast<UIItemHostNetwork*>(pItem);
AssertMsgReturnVoid(pChangedItem, ("Changed item must not be null!\n"));
/* Get item data: */
UIDataHostNetwork oldData = *pChangedItem;
/* Make sure dhcp server status changed: */
if ( ( oldData.m_dhcpserver.m_fEnabled
&& pChangedItem->checkState(Column_DHCP) == Qt::Checked)
|| ( !oldData.m_dhcpserver.m_fEnabled
&& pChangedItem->checkState(Column_DHCP) == Qt::Unchecked))
return;
/* Get host for further activities: */
CHost comHost = vboxGlobal().host();
/* Find corresponding interface: */
CHostNetworkInterface comInterface = comHost.FindHostNetworkInterfaceByName(oldData.m_interface.m_strName);
/* Show error message if necessary: */
if (!comHost.isOk() || comInterface.isNull())
msgCenter().cannotFindHostNetworkInterface(comHost, oldData.m_interface.m_strName, this);
else
{
/* Get network name for further activities: */
const QString strNetworkName = comInterface.GetNetworkName();
/* Show error message if necessary: */
if (!comInterface.isOk())
msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
else
{
/* Get VBox for further activities: */
CVirtualBox comVBox = vboxGlobal().virtualBox();
/* Find corresponding DHCP server (create if necessary): */
CDHCPServer comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
if (!comVBox.isOk() || comServer.isNull())
comServer = comVBox.CreateDHCPServer(strNetworkName);
/* Show error message if necessary: */
if (!comVBox.isOk() || comServer.isNull())
msgCenter().cannotCreateDHCPServer(comVBox, strNetworkName, this);
else
{
/* Save whether DHCP server is enabled: */
if (comServer.isOk())
comServer.SetEnabled(!oldData.m_dhcpserver.m_fEnabled);
/* Save default DHCP server configuration if current is invalid: */
if ( comServer.isOk()
&& !oldData.m_dhcpserver.m_fEnabled
&& ( oldData.m_dhcpserver.m_strAddress == "0.0.0.0"
|| oldData.m_dhcpserver.m_strMask == "0.0.0.0"
|| oldData.m_dhcpserver.m_strLowerAddress == "0.0.0.0"
|| oldData.m_dhcpserver.m_strUpperAddress == "0.0.0.0"))
{
const QStringList &proposal = makeDhcpServerProposal(oldData.m_interface.m_strAddress,
oldData.m_interface.m_strMask);
comServer.SetConfiguration(proposal.at(0), proposal.at(1), proposal.at(2), proposal.at(3));
}
/* Show error message if necessary: */
if (!comServer.isOk())
msgCenter().cannotSaveDHCPServerParameter(comServer, this);
{
/* Update interface in the tree: */
UIDataHostNetwork data;
loadHostNetwork(comInterface, data);
updateItemForNetworkHost(data, true, pChangedItem);
/* Make sure current item fetched: */
sltHandleCurrentItemChange();
/* Adjust tree-widget: */
sltAdjustTreeWidget();
}
}
}
}
}
void UIHostNetworkManagerWidget::sltRemoveHostNetwork()
{
/* Get network item: */
UIItemHostNetwork *pItem = static_cast<UIItemHostNetwork*>(m_pTreeWidget->currentItem());
AssertMsgReturnVoid(pItem, ("Current item must not be null!\n"));
/* Get interface name: */
const QString strInterfaceName(pItem->name());
/* Confirm host network removal: */
if (!msgCenter().confirmHostOnlyInterfaceRemoval(strInterfaceName, this))
return;
/* Get host for further activities: */
CHost comHost = vboxGlobal().host();
/* Find corresponding interface: */
const CHostNetworkInterface &comInterface = comHost.FindHostNetworkInterfaceByName(strInterfaceName);
/* Show error message if necessary: */
if (!comHost.isOk() || comInterface.isNull())
msgCenter().cannotFindHostNetworkInterface(comHost, strInterfaceName, this);
else
{
/* Get network name for further activities: */
QString strNetworkName;
if (comInterface.isOk())
strNetworkName = comInterface.GetNetworkName();
/* Get interface id for further activities: */
QUuid uInterfaceId;
if (comInterface.isOk())
uInterfaceId = comInterface.GetId();
/* Show error message if necessary: */
if (!comInterface.isOk())
msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
else
{
/* Get VBox for further activities: */
CVirtualBox comVBox = vboxGlobal().virtualBox();
/* Find corresponding DHCP server: */
const CDHCPServer &comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
if (comVBox.isOk() && comServer.isNotNull())
{
/* Remove server if any: */
comVBox.RemoveDHCPServer(comServer);
/* Show error message if necessary: */
if (!comVBox.isOk())
msgCenter().cannotRemoveDHCPServer(comVBox, strInterfaceName, this);
}
/* Remove interface finally: */
CProgress progress = comHost.RemoveHostOnlyNetworkInterface(uInterfaceId);
/* Show error message if necessary: */
if (!comHost.isOk() || progress.isNull())
msgCenter().cannotRemoveHostNetworkInterface(comHost, strInterfaceName, this);
else
{
/* Show interface removal progress: */
msgCenter().showModalProgressDialog(progress, UIHostNetworkManager::tr("Removing network..."), ":/progress_network_interface_90px.png", this, 0);
/* Show error message if necessary: */
if (!progress.isOk() || progress.GetResultCode() != 0)
return msgCenter().cannotRemoveHostNetworkInterface(progress, strInterfaceName, this);
else
{
/* Remove interface from the tree: */
delete pItem;
/* Adjust tree-widget: */
sltAdjustTreeWidget();
}
}
}
}
}
void UIHostNetworkManagerWidget::sltApplyHostNetworkDetailsChanges()
{
/* Get network item: */
UIItemHostNetwork *pItem = static_cast<UIItemHostNetwork*>(m_pTreeWidget->currentItem());
AssertMsgReturnVoid(pItem, ("Current item must not be null!\n"));
/* Get item data: */
UIDataHostNetwork oldData = *pItem;
UIDataHostNetwork newData = m_pDetailsWidget->data();
/* Get host for further activities: */
CHost comHost = vboxGlobal().host();
/* Find corresponding interface: */
CHostNetworkInterface comInterface = comHost.FindHostNetworkInterfaceByName(oldData.m_interface.m_strName);
/* Show error message if necessary: */
if (!comHost.isOk() || comInterface.isNull())
msgCenter().cannotFindHostNetworkInterface(comHost, oldData.m_interface.m_strName, this);
else
{
/* Save automatic interface configuration: */
if (newData.m_interface.m_fDHCPEnabled)
{
if ( comInterface.isOk()
&& !oldData.m_interface.m_fDHCPEnabled)
comInterface.EnableDynamicIPConfig();
}
/* Save manual interface configuration: */
else
{
/* Save IPv4 interface configuration: */
if ( comInterface.isOk()
&& ( oldData.m_interface.m_fDHCPEnabled
|| newData.m_interface.m_strAddress != oldData.m_interface.m_strAddress
|| newData.m_interface.m_strMask != oldData.m_interface.m_strMask))
comInterface.EnableStaticIPConfig(newData.m_interface.m_strAddress, newData.m_interface.m_strMask);
/* Save IPv6 interface configuration: */
if ( comInterface.isOk()
&& newData.m_interface.m_fSupportedIPv6
&& ( oldData.m_interface.m_fDHCPEnabled
|| newData.m_interface.m_strAddress6 != oldData.m_interface.m_strAddress6
|| newData.m_interface.m_strPrefixLength6 != oldData.m_interface.m_strPrefixLength6))
comInterface.EnableStaticIPConfigV6(newData.m_interface.m_strAddress6, newData.m_interface.m_strPrefixLength6.toULong());
}
/* Show error message if necessary: */
if (!comInterface.isOk())
msgCenter().cannotSaveHostNetworkInterfaceParameter(comInterface, this);
else
{
/* Get network name for further activities: */
const QString strNetworkName = comInterface.GetNetworkName();
/* Show error message if necessary: */
if (!comInterface.isOk())
msgCenter().cannotAcquireHostNetworkInterfaceParameter(comInterface, this);
else
{
/* Get VBox for further activities: */
CVirtualBox comVBox = vboxGlobal().virtualBox();
/* Find corresponding DHCP server (create if necessary): */
CDHCPServer comServer = comVBox.FindDHCPServerByNetworkName(strNetworkName);
if (!comVBox.isOk() || comServer.isNull())
comServer = comVBox.CreateDHCPServer(strNetworkName);
/* Show error message if necessary: */
if (!comVBox.isOk() || comServer.isNull())
msgCenter().cannotCreateDHCPServer(comVBox, strNetworkName, this);
else
{
/* Save whether DHCP server is enabled: */
if ( comServer.isOk()
&& newData.m_dhcpserver.m_fEnabled != oldData.m_dhcpserver.m_fEnabled)
comServer.SetEnabled(newData.m_dhcpserver.m_fEnabled);
/* Save DHCP server configuration: */
if ( comServer.isOk()
&& newData.m_dhcpserver.m_fEnabled
&& ( newData.m_dhcpserver.m_strAddress != oldData.m_dhcpserver.m_strAddress
|| newData.m_dhcpserver.m_strMask != oldData.m_dhcpserver.m_strMask
|| newData.m_dhcpserver.m_strLowerAddress != oldData.m_dhcpserver.m_strLowerAddress
|| newData.m_dhcpserver.m_strUpperAddress != oldData.m_dhcpserver.m_strUpperAddress))
comServer.SetConfiguration(newData.m_dhcpserver.m_strAddress, newData.m_dhcpserver.m_strMask,
newData.m_dhcpserver.m_strLowerAddress, newData.m_dhcpserver.m_strUpperAddress);
/* Show error message if necessary: */
if (!comServer.isOk())
msgCenter().cannotSaveDHCPServerParameter(comServer, this);
}
}
}
/* Find corresponding interface again (if necessary): */
if (!comInterface.isOk())
{
comInterface = comHost.FindHostNetworkInterfaceByName(oldData.m_interface.m_strName);
/* Show error message if necessary: */
if (!comHost.isOk() || comInterface.isNull())
msgCenter().cannotFindHostNetworkInterface(comHost, oldData.m_interface.m_strName, this);
}
/* If interface is Ok now: */
if (comInterface.isNotNull() && comInterface.isOk())
{
/* Update interface in the tree: */
UIDataHostNetwork data;
loadHostNetwork(comInterface, data);
updateItemForNetworkHost(data, true, pItem);
/* Make sure current item fetched: */
sltHandleCurrentItemChange();
/* Adjust tree-widget: */
sltAdjustTreeWidget();
}
}
}
/**
* Free a memory block.
*
* @param pHeapInt The heap.
* @param pBlock The memory block to free.
*/
static void rtHeapSimpleFreeBlock(PRTHEAPSIMPLEINTERNAL pHeapInt, PRTHEAPSIMPLEBLOCK pBlock)
{
PRTHEAPSIMPLEFREE pFree = (PRTHEAPSIMPLEFREE)pBlock;
PRTHEAPSIMPLEFREE pLeft;
PRTHEAPSIMPLEFREE pRight;
#ifdef RTHEAPSIMPLE_STRICT
rtHeapSimpleAssertAll(pHeapInt);
#endif
/*
* Look for the closest free list blocks by walking the blocks right
* of us (both lists are sorted by address).
*/
pLeft = NULL;
pRight = NULL;
if (pHeapInt->pFreeTail)
{
pRight = (PRTHEAPSIMPLEFREE)pFree->Core.pNext;
while (pRight && !RTHEAPSIMPLEBLOCK_IS_FREE(&pRight->Core))
{
ASSERT_BLOCK(pHeapInt, &pRight->Core);
pRight = (PRTHEAPSIMPLEFREE)pRight->Core.pNext;
}
if (!pRight)
pLeft = pHeapInt->pFreeTail;
else
{
ASSERT_BLOCK_FREE(pHeapInt, pRight);
pLeft = pRight->pPrev;
}
if (pLeft)
ASSERT_BLOCK_FREE(pHeapInt, pLeft);
}
AssertMsgReturnVoid(pLeft != pFree, ("Freed twice! pv=%p (pBlock=%p)\n", pBlock + 1, pBlock));
ASSERT_L(pLeft, pFree);
Assert(!pRight || (uintptr_t)pRight > (uintptr_t)pFree);
Assert(!pLeft || pLeft->pNext == pRight);
/*
* Insert at the head of the free block list?
*/
if (!pLeft)
{
Assert(pRight == pHeapInt->pFreeHead);
pFree->Core.fFlags |= RTHEAPSIMPLEBLOCK_FLAGS_FREE;
pFree->pPrev = NULL;
pFree->pNext = pRight;
if (pRight)
pRight->pPrev = pFree;
else
pHeapInt->pFreeTail = pFree;
pHeapInt->pFreeHead = pFree;
}
else
{
/*
* Can we merge with left hand free block?
*/
if (pLeft->Core.pNext == &pFree->Core)
{
pLeft->Core.pNext = pFree->Core.pNext;
if (pFree->Core.pNext)
pFree->Core.pNext->pPrev = &pLeft->Core;
pHeapInt->cbFree -= pLeft->cb;
pFree = pLeft;
}
/*
* No, just link it into the free list then.
*/
else
{
pFree->Core.fFlags |= RTHEAPSIMPLEBLOCK_FLAGS_FREE;
pFree->pNext = pRight;
pFree->pPrev = pLeft;
pLeft->pNext = pFree;
if (pRight)
pRight->pPrev = pFree;
else
pHeapInt->pFreeTail = pFree;
}
}
/*
* Can we merge with right hand free block?
*/
if ( pRight
&& pRight->Core.pPrev == &pFree->Core)
{
/* core */
pFree->Core.pNext = pRight->Core.pNext;
if (pRight->Core.pNext)
pRight->Core.pNext->pPrev = &pFree->Core;
/* free */
pFree->pNext = pRight->pNext;
if (pRight->pNext)
pRight->pNext->pPrev = pFree;
else
pHeapInt->pFreeTail = pFree;
pHeapInt->cbFree -= pRight->cb;
}
/*
* Calculate the size and update free stats.
*/
pFree->cb = (pFree->Core.pNext ? (uintptr_t)pFree->Core.pNext : (uintptr_t)pHeapInt->pvEnd)
- (uintptr_t)pFree - sizeof(RTHEAPSIMPLEBLOCK);
pHeapInt->cbFree += pFree->cb;
ASSERT_BLOCK_FREE(pHeapInt, pFree);
#ifdef RTHEAPSIMPLE_STRICT
rtHeapSimpleAssertAll(pHeapInt);
#endif
}
