RTDECL(bool) RTManifestEntryExists(RTMANIFEST hManifest, const char *pszEntry) { RTMANIFESTINT *pThis = hManifest; AssertPtrReturn(pThis, false); AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, false); AssertPtr(pszEntry); bool fNeedNormalization; size_t cchEntry; int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry); AssertRCReturn(rc, false); /* * Check if it exists. */ PRTMANIFESTENTRY pEntry; rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry); return RT_SUCCESS_NP(rc); }
DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance) { LogFlowFuncEnter(); PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */ AssertPtr(pCtx); if (pCtx->pEnv) { /* Clipboard was already initialized. 2 or more instances are not supported. */ return VERR_NOT_SUPPORTED; } if (VbglR3AutoLogonIsRemoteSession()) { /* Do not use clipboard for remote sessions. */ LogRel(("Clipboard: Clipboard has been disabled for a remote session\n")); return VERR_NOT_SUPPORTED; } RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT)); pCtx->pEnv = pEnv; /* Check that new Clipboard API is available */ vboxClipboardInitNewAPI(pCtx); int rc = VbglR3ClipboardConnect(&pCtx->u32ClientID); if (RT_SUCCESS(rc)) { rc = vboxClipboardCreateWindow(pCtx); if (RT_SUCCESS(rc)) { *ppInstance = pCtx; } else { VbglR3ClipboardDisconnect(pCtx->u32ClientID); } } LogFlowFuncLeaveRC(rc); return rc; }
/** * Logs a verbose message. * * @param pszFormat The message text. * @param va Format arguments. */ void VGSvcLogV(const char *pszFormat, va_list va) { #ifdef DEBUG int rc = RTCritSectEnter(&g_csLog); if (RT_SUCCESS(rc)) { #endif char *psz = NULL; RTStrAPrintfV(&psz, pszFormat, va); AssertPtr(psz); LogRel(("%s", psz)); RTStrFree(psz); #ifdef DEBUG RTCritSectLeave(&g_csLog); } #endif }
RTDECL(void) RTSpinlockAcquire(RTSPINLOCK Spinlock) { PRTSPINLOCKINTERNAL pThis = (PRTSPINLOCKINTERNAL)Spinlock; RT_ASSERT_PREEMPT_CPUID_VAR(); AssertPtr(pThis); Assert(pThis->u32Magic == RTSPINLOCK_MAGIC); if (pThis->fFlags & RTSPINLOCK_FLAGS_INTERRUPT_SAFE) { #if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) uint32_t fIntSaved = ASMIntDisableFlags(); #endif mutex_enter(&pThis->Mtx); /* * Solaris 10 doesn't preserve the interrupt flag, but since we're at PIL_MAX we should be * fine and not get interrupts while lock is held. Re-disable interrupts to not upset * assertions & assumptions callers might have. */ #if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) ASMIntDisable(); #endif #if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) Assert(!ASMIntAreEnabled()); #endif pThis->fIntSaved = fIntSaved; } else { #if defined(RT_STRICT) && (defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)) bool fIntsOn = ASMIntAreEnabled(); #endif mutex_enter(&pThis->Mtx); #if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86) AssertMsg(fIntsOn == ASMIntAreEnabled(), ("fIntsOn=%RTbool\n", fIntsOn)); #endif } RT_ASSERT_PREEMPT_CPUID_SPIN_ACQUIRED(pThis); }
/** * Invokes the write-MSR handler for the GIM provider configured for the VM. * * @returns Strict VBox status code like CPUMSetGuestMsr. * @retval VINF_CPUM_R3_MSR_WRITE * @retval VERR_CPUM_RAISE_GP_0 * * @param pVCpu Pointer to the VMCPU. * @param idMsr The MSR to write. * @param pRange The range this MSR belongs to. * @param uValue The value to set, ignored bits masked. * @param uRawValue The raw value with the ignored bits not masked. */ VMM_INT_DECL(VBOXSTRICTRC) GIMWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue) { AssertPtr(pVCpu); NOREF(uValue); PVM pVM = pVCpu->CTX_SUFF(pVM); Assert(GIMIsEnabled(pVM)); VMCPU_ASSERT_EMT(pVCpu); switch (pVM->gim.s.enmProviderId) { case GIMPROVIDERID_HYPERV: return GIMHvWriteMsr(pVCpu, idMsr, pRange, uRawValue); default: AssertMsgFailed(("GIMWriteMsr: for unknown provider %u idMsr=%#RX32 -> #GP(0)", pVM->gim.s.enmProviderId, idMsr)); return VERR_CPUM_RAISE_GP_0; } }
void VBoxSeamlessDestroy(void *pInstance) { LogFlowFuncEnter(); PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance; AssertPtr(pCtx); VBoxSeamlessSetSupported(FALSE); /* Inform the host that we no longer support the seamless window mode. */ if (pCtx->pfnVBoxHookRemoveWindowTracker) pCtx->pfnVBoxHookRemoveWindowTracker(); if (pCtx->hModHook != NIL_RTLDRMOD) { RTLdrClose(pCtx->hModHook); pCtx->hModHook = NIL_RTLDRMOD; } return; }
/** * Internal worker for the RTMpOn* APIs using KeIpiGenericCall. * * @returns IPRT status code. * @param pfnWorker The callback. * @param pvUser1 User argument 1. * @param pvUser2 User argument 2. * @param enmCpuid What to do / is idCpu valid. * @param idCpu Used if enmCpuid RT_NT_CPUID_SPECIFIC, otherwise ignored. */ static int rtMpCallUsingBroadcastIpi(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2, PKIPI_BROADCAST_WORKER pfnNativeWrapper, RTCPUID idCpu) { RTMPARGS Args; Args.pfnWorker = pfnWorker; Args.pvUser1 = pvUser1; Args.pvUser2 = pvUser2; Args.idCpu = idCpu; Args.cRefs = 0; Args.cHits = 0; AssertPtr(g_pfnrtKeIpiGenericCall); g_pfnrtKeIpiGenericCall(pfnNativeWrapper, (uintptr_t)&Args); if ( pfnNativeWrapper != rtmpNtOnSpecificBroadcastIpiWrapper || Args.cHits > 0) return VINF_SUCCESS; return VERR_CPU_OFFLINE; }
/** * Destroys a DBGC instance created by dbgcCreate. * * @param pDbgc Pointer to the debugger console instance data. */ void dbgcDestroy(PDBGC pDbgc) { AssertPtr(pDbgc); /* Disable log hook. */ if (pDbgc->fLog) { } /* Unload all plug-ins. */ dbgcPlugInUnloadAll(pDbgc); /* Detach from the VM. */ if (pDbgc->pVM) DBGFR3Detach(pDbgc->pVM); /* finally, free the instance memory. */ RTMemFree(pDbgc); }
bool DevAssetManager::ContainsAsset( const char* filePath ) const { AssertPtr(filePath); VRET_FALSE_IF_NIL(filePath); String fileName( filePath ); // check if the file is located in source assets folder and extract its name { const bool casesensitive = true; const INT pos = String::FindText( filePath, m_pathToSrcAssets, casesensitive ); if( pos != INDEX_NONE ) { // get file name relative to base folder fileName.StripLeadingOnce( m_pathToSrcAssets ); } } return m_assetIDs.FindGuidByName( fileName ) != nil; }
/*---------------------------------------------------------------------------------------------- Open a key, which is the name of a Graphite font, and return a handle to it. @param pszFontKey - the name of the font @param pszStyle - regular, bold, italic, bolditalic; ignored here--caller opens string value @param at - access @param phkey - handle to return ----------------------------------------------------------------------------------------------*/ bool GrUtil::OpenFontKey(const utf16 * pszFontKey, const utf16 * pszStyle, AccessType at, HKEY * phkey) { AssertPsz((const wchar_t*)pszFontKey); AssertPsz((const wchar_t*)pszStyle); AssertPtr(phkey); //#ifdef GR_FW // StrApp str; // str.Format(_T("Software\\SIL\\GraphiteFonts\\%s"), pszFontKey); //#else OLECHAR str[260]; _stprintf_s(str, _T("Software\\SIL\\GraphiteFonts\\%s"), (wchar_t*)pszFontKey); //#endif if (at == katRead) return ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, str, 0, at, phkey) == ERROR_SUCCESS; return ::RegCreateKeyEx(HKEY_LOCAL_MACHINE, str, 0, NULL, 0, at, NULL, phkey, NULL) == ERROR_SUCCESS; }
/** * Checks if receive is possible and increases busy and ref counters if so. * * @param pThis The instance. */ DECLHIDDEN(bool) vboxNetAdpPrepareToReceive(PVBOXNETADP pThis) { bool fCanReceive = false; /* * Input validation. */ AssertPtr(pThis); Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION); RTSpinlockAcquire(pThis->hSpinlock); if (vboxNetAdpGetState(pThis) == kVBoxNetAdpState_Active) { fCanReceive = true; vboxNetAdpRetain(pThis); vboxNetAdpBusy(pThis); } RTSpinlockRelease(pThis->hSpinlock); Log(("vboxNetAdpPrepareToReceive: fCanReceive=%d.\n", fCanReceive)); return fCanReceive; }
/*---------------------------------------------------------------------------------------------- Get the empty string for this thread. ----------------------------------------------------------------------------------------------*/ void TextServGlobals::GetEmptyString(ITsString ** pptss) { AssertPtr(pptss); Assert(!*pptss); TextServGlobals * ptsg = GetTsGlobals(); if (!ptsg->m_qtssEmpty) { if (ptsg->m_cactActive <= 0) { Warn("Empty string requested with no active clients"); TsStrSingle::Create((OLECHAR *)NULL, 0, NULL, pptss); } TsStrSingle::Create((OLECHAR *)NULL, 0, NULL, &ptsg->m_qtssEmpty); } *pptss = ptsg->m_qtssEmpty; AddRefObj(*pptss); }
/*********************************************************************************************** IUnknown Methods ***********************************************************************************************/ STDMETHODIMP AfFwTool::QueryInterface(REFIID riid, void **ppv) { AssertPtr(ppv); if (!ppv) return WarnHr(E_POINTER); *ppv = NULL; if (riid == IID_IUnknown) *ppv = static_cast<IUnknown *>(this); else if (riid == IID_IFwTool) *ppv = static_cast<IFwTool *>(this); else // Note: When we use the ROT, we get numerous calls here, including IID_IProxyManager, // IID_IMarshal, IID_IStdMarshalInfo, IID_IExternalConnection, etc. We should not be // using a WarnHr. return E_NOINTERFACE; AddRef(); return NOERROR; }
RTDECL(int) RTThreadCtxHooksDeregister(RTTHREADCTX hThreadCtx) { /* * Validate input. */ PRTTHREADCTXINT pThis = hThreadCtx; if (pThis == NIL_RTTHREADCTX) return VERR_INVALID_HANDLE; AssertPtr(pThis); AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis), VERR_INVALID_HANDLE); Assert(pThis->hOwner == RTThreadNativeSelf()); Assert(pThis->fRegistered); /* * Deregister the callback. */ rtThreadCtxHooksDeregister(pThis); return VINF_SUCCESS; }
/** * Reads a guest property as a 32-bit value. * * @returns VBox status code, fully bitched. * * @param u32ClientId The HGCM client ID for the guest property session. * @param pszPropName The property name. * @param pu32 Where to store the 32-bit value. * */ int VBoxServiceReadPropUInt32(uint32_t u32ClientId, const char *pszPropName, uint32_t *pu32, uint32_t u32Min, uint32_t u32Max) { char *pszValue; int rc = VBoxServiceReadProp(u32ClientId, pszPropName, &pszValue, NULL /* ppszFlags */, NULL /* puTimestamp */); if (RT_SUCCESS(rc)) { AssertPtr(pu32); char *pszNext; rc = RTStrToUInt32Ex(pszValue, &pszNext, 0, pu32); if ( RT_SUCCESS(rc) && (*pu32 < u32Min || *pu32 > u32Max)) { rc = VBoxServiceError("The guest property value %s = %RU32 is out of range [%RU32..%RU32].\n", pszPropName, *pu32, u32Min, u32Max); } RTStrFree(pszValue); } return rc; }
static void pdmNsBwGroupUnlink(PPDMNSBWGROUP pBwGroup) { PPDMNETSHAPER pShaper = pBwGroup->pShaper; LOCK_NETSHAPER(pShaper); if (pBwGroup == pShaper->pBwGroupsHead) pShaper->pBwGroupsHead = pBwGroup->pNext; else { PPDMNSBWGROUP pPrev = pShaper->pBwGroupsHead; while ( pPrev && pPrev->pNext != pBwGroup) pPrev = pPrev->pNext; AssertPtr(pPrev); pPrev->pNext = pBwGroup->pNext; } UNLOCK_NETSHAPER(pShaper); }
static void pdmNsBwGroupUnlink(PPDMNSBWGROUP pBwGroup) { PPDMNETSHAPER pShaper = pBwGroup->pShaper; int rc = RTCritSectEnter(&pShaper->cs); AssertRC(rc); if (pBwGroup == pShaper->pBwGroupsHead) pShaper->pBwGroupsHead = pBwGroup->pNext; else { PPDMNSBWGROUP pPrev = pShaper->pBwGroupsHead; while ( pPrev && pPrev->pNext != pBwGroup) pPrev = pPrev->pNext; AssertPtr(pPrev); pPrev->pNext = pBwGroup->pNext; } rc = RTCritSectLeave(&pShaper->cs); AssertRC(rc); }
/** * @interface_method_impl{PDMIVMMDEVCONNECTOR,pfnUpdateGuestInfo2} */ DECLCALLBACK(void) vmmdevUpdateGuestInfo2(PPDMIVMMDEVCONNECTOR pInterface, uint32_t uFullVersion, const char *pszName, uint32_t uRevision, uint32_t fFeatures) { PDRVMAINVMMDEV pDrv = RT_FROM_MEMBER(pInterface, DRVMAINVMMDEV, Connector); AssertPtr(pszName); Assert(uFullVersion); /* Store that information in IGuest. */ Guest *pGuest = pDrv->pVMMDev->getParent()->i_getGuest(); AssertPtrReturnVoid(pGuest); /* Just pass it on... */ pGuest->i_setAdditionsInfo2(uFullVersion, pszName, uRevision, fFeatures); /* * No need to tell the console interface about the update; * vmmdevUpdateGuestInfo takes care of that when called as the * last event in the chain. */ }
/** * Creates our provider. This happens *before* CTRL-ALT-DEL was pressed! */ HRESULT VBoxCredProvProviderCreate(REFIID interfaceID, void **ppvInterface) { HRESULT hr; try { VBoxCredProvProvider *pProvider = new VBoxCredProvProvider(); AssertPtr(pProvider); hr = pProvider->QueryInterface(interfaceID, ppvInterface); pProvider->Release(); } catch (std::bad_alloc &ex) { NOREF(ex); hr = E_OUTOFMEMORY; } return hr; }
RTDECL(int) RTPipeWriteBlocking(RTPIPE hPipe, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten) { RTPIPEINTERNAL *pThis = hPipe; AssertPtrReturn(pThis, VERR_INVALID_HANDLE); AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE); AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED); AssertPtr(pvBuf); AssertPtrNull(pcbWritten); int rc = rtPipeTryBlocking(pThis); if (RT_SUCCESS(rc)) { size_t cbTotalWritten = 0; while (cbToWrite > 0) { ssize_t cbWritten = write(pThis->fd, pvBuf, RT_MIN(cbToWrite, SSIZE_MAX)); if (cbWritten < 0) { rc = RTErrConvertFromErrno(errno); break; } /* advance */ pvBuf = (char const *)pvBuf + cbWritten; cbTotalWritten += cbWritten; cbToWrite -= cbWritten; } if (pcbWritten) { *pcbWritten = cbTotalWritten; if ( RT_FAILURE(rc) && cbTotalWritten && rc != VERR_INVALID_POINTER) rc = VINF_SUCCESS; } ASMAtomicDecU32(&pThis->u32State); } return rc; }
/** * Adds a line number to the module. * * @returns IPRT status code. * @retval VERR_NOT_SUPPORTED if the module interpret doesn't support adding * custom symbols. This should be consider a normal response. * @retval VERR_INVALID_HANDLE if hDbgMod is invalid. * @retval VERR_DBG_FILE_NAME_OUT_OF_RANGE if the file name is too longer or * empty. * @retval VERR_DBG_INVALID_RVA if an image relative address is specified and * it's not inside any of the segments defined by the module. * @retval VERR_DBG_INVALID_SEGMENT_INDEX if the segment index isn't valid. * @retval VERR_DBG_INVALID_SEGMENT_OFFSET if the segment offset is beyond the * end of the segment. * @retval VERR_INVALID_PARAMETER if the line number flags sets undefined bits. * * @param hDbgMod The module handle. * @param pszFile The file name. * @param uLineNo The line number. * @param iSeg The segment index. * @param off The segment offset. * @param piOrdinal Where to return the line number ordinal on * success. If the interpreter doesn't do ordinals, * this will be set to UINT32_MAX. Optional. */ RTDECL(int) RTDbgModLineAdd(RTDBGMOD hDbgMod, const char *pszFile, uint32_t uLineNo, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t *piOrdinal) { /* * Validate input. */ PRTDBGMODINT pDbgMod = hDbgMod; RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE); AssertPtr(pszFile); size_t cchFile = strlen(pszFile); AssertReturn(cchFile, VERR_DBG_FILE_NAME_OUT_OF_RANGE); AssertReturn(cchFile < RTDBG_FILE_NAME_LENGTH, VERR_DBG_FILE_NAME_OUT_OF_RANGE); AssertMsgReturn( iSeg <= RTDBGSEGIDX_LAST || iSeg == RTDBGSEGIDX_RVA, ("%#x\n", iSeg), VERR_DBG_INVALID_SEGMENT_INDEX); AssertReturn(uLineNo > 0 && uLineNo < UINT32_MAX, VERR_INVALID_PARAMETER); RTDBGMOD_LOCK(pDbgMod); /* * Convert RVAs. */ if (iSeg == RTDBGSEGIDX_RVA) { iSeg = pDbgMod->pDbgVt->pfnRvaToSegOff(pDbgMod, off, &off); if (iSeg == NIL_RTDBGSEGIDX) { RTDBGMOD_UNLOCK(pDbgMod); return VERR_DBG_INVALID_RVA; } } /* * Get down to business. */ int rc = pDbgMod->pDbgVt->pfnLineAdd(pDbgMod, pszFile, cchFile, uLineNo, iSeg, off, piOrdinal); RTDBGMOD_UNLOCK(pDbgMod); return rc; }
/*---------------------------------------------------------------------------------------------- Check the requirments of the FldSpec, and verify that data in the field meets the requirement. It returns: kFTReqNotReq if the all requirements are met. kFTReqWs if data is missing, but it is encouraged. kFTReqReq if data is missing, but it is required. ----------------------------------------------------------------------------------------------*/ FldReq AfDeFeSt::HasRequiredData() { if (m_qfsp->m_fRequired == kFTReqNotReq) return kFTReqNotReq; CustViewDaPtr qcvd; GetDataAccess(&qcvd); AssertPtr(qcvd); bool fEmpty = true; ITsStringPtr qtss; int cch = 0; HVO hvoPara; int iPara; if (!m_hvoText) goto LExit; int cPara; CheckHr(qcvd->get_VecSize(m_hvoText, kflidStText_Paragraphs, &cPara)); if (!cPara) goto LExit; // Make sure at least some paragraph has data. for (iPara = 0; iPara < cPara; ++iPara) { CheckHr(qcvd->get_VecItem(m_hvoText, kflidStText_Paragraphs, iPara, &hvoPara)); // At some point we may need to handle something other than StTxtPara. CheckHr(qcvd->get_StringProp(hvoPara, kflidStTxtPara_Contents, &qtss)); if (qtss) CheckHr(qtss->get_Length(&cch)); if (cch) break; // Have a valid string } fEmpty = iPara == cPara; LExit: if (fEmpty) return m_qfsp->m_fRequired; else return kFTReqNotReq; }
/** * Get the real name of a shared folder. * * @returns VBox status code. * @param u32ClientId The client id returned by VbglR3InvsSvcConnect(). * @param u32Root Root ID of shared folder to get the name for. * @param ppszName Where to return the name string. This shall be * freed by calling RTStrFree. */ VBGLR3DECL(int) VbglR3SharedFolderGetName(uint32_t u32ClientId, uint32_t u32Root, char **ppszName) { AssertPtr(ppszName); VBoxSFQueryMapName Msg; Msg.callInfo.result = VERR_WRONG_ORDER; Msg.callInfo.u32ClientID = u32ClientId; Msg.callInfo.u32Function = SHFL_FN_QUERY_MAP_NAME; Msg.callInfo.cParms = 2; int rc; uint32_t cbString = SHFLSTRING_HEADER_SIZE + SHFL_MAX_LEN; PSHFLSTRING pString = (PSHFLSTRING)RTMemAlloc(cbString); if (pString) { if (!ShflStringInitBuffer(pString, cbString)) { RTMemFree(pString); return VERR_INVALID_PARAMETER; } VbglHGCMParmUInt32Set(&Msg.root, u32Root); VbglHGCMParmPtrSet(&Msg.name, pString, cbString); rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg)); if (RT_SUCCESS(rc)) { rc = Msg.callInfo.result; if (RT_SUCCESS(rc)) { *ppszName = NULL; rc = RTUtf16ToUtf8(&pString->String.ucs2[0], ppszName); } } RTMemFree(pString); } else rc = VERR_INVALID_PARAMETER; return rc; }
QWidget* GetPropertyEditor( AEditableProperty* theProperty ) { if (theProperty->Is<EdProperty_Bool>()) { return static_cast< BoolPropertyEditor*>( theProperty->editor.Ptr ); } else if (theProperty->Is<EdProperty_UInt32>()) { return static_cast< UInt32PropertyEditor*>( theProperty->editor.Ptr ); } else if (theProperty->Is<EdProperty_Float>()) { return static_cast< FloatPropertyEditor*>( theProperty->editor.Ptr ); } else if (theProperty->Is<EdProperty_Vector3D>()) { return static_cast< Vec3DPropertyEditor*>( theProperty->editor.Ptr ); } else if (theProperty->Is<EdProperty_Quat>()) { return static_cast< QuaternionPropertyEditor*>( theProperty->editor.Ptr ); } else if (theProperty->Is<EdProperty_Array>()) { // each item of the array will have a separate editor return nil; } //else if (theProperty->Is<EdProperty_AssetReference>()) //{ // return static_cast< ResourceRefPropertyEditor*>( theProperty->editor.Ptr ); //} else { APropertyEditor* pEditor = theProperty->editor; AssertPtr(pEditor); return static_cast<QWidget*>(static_cast<void*>(pEditor)); /*DBGOUT("Unknown property: '%s'\n",theProperty->edToChars(0)); Unimplemented; return nil;*/ } }
DEFINE_THIS_FILE //:End Ignore //:>******************************************************************************************** //:> PropertiesDlg Implementation //:>******************************************************************************************** /*---------------------------------------------------------------------------------------------- Process notifications for this dialog from some event on a control. This method is called by the framework. @param ctid Id of the control that issued the windows command. @param pnmh Windows command that is being passed. @param lnRet return value to be returned to the windows command. @return true if command is handled. See ${AfWnd#OnNotifyChild} ----------------------------------------------------------------------------------------------*/ bool PropertiesDlg::OnNotifyChild(int ctid, NMHDR * pnmh, long & lnRet) { AssertPtr(pnmh); int itab; switch (pnmh->code) { case TCN_SELCHANGE: // Make sure we can move to the current tab. itab = TabCtrl_GetCurSel(m_hwndTab); Assert((uint)itab < (uint)m_vqdlgv.Size()); ShowChildDlg(itab); return true; case TCN_SELCHANGING: // Make sure that we can move off of the current tab. itab = TabCtrl_GetCurSel(m_hwndTab); Assert((uint)itab < (uint)m_vqdlgv.Size()); lnRet = !m_vqdlgv[itab]->QueryClose(AfDialogView::kqctChange); return true; } return SuperClass::OnNotifyChild(ctid, pnmh, lnRet); }
/** * Send a byte (keystroke or command response) to the keyboard controller. * * @returns VINF_SUCCESS or VINF_TRY_AGAIN. * @param pThis The PS/2 auxiliary device instance data. * @param pb Where to return the byte we've read. * @remarks Caller must have entered the device critical section. */ int PS2MByteFromAux(PPS2M pThis, uint8_t *pb) { int rc; AssertPtr(pb); /* Anything in the command queue has priority over data * in the event queue. Additionally, keystrokes are //@todo: true? * blocked if a command is currently in progress, even if * the command queue is empty. */ //@todo: Probably should flush/not fill queue if stream mode reporting disabled?! rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb); if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && (pThis->u8State & AUX_STATE_ENABLED)) rc = ps2kRemoveQueue((GeneriQ *)&pThis->evtQ, pb); LogFlowFunc(("mouse sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not ")); //if (rc == VINF_SUCCESS) LogRel(("aux: sends 0x%02X\n", *pb)); return rc; }
/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */ static DECLCALLBACK(int) rawSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid) { LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid)); PRAWIMAGE pImage = (PRAWIMAGE)pBackendData; int rc; AssertPtr(pImage); if (pImage) { if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)) rc = VERR_NOT_SUPPORTED; else rc = VERR_VD_IMAGE_READ_ONLY; } else rc = VERR_VD_NOT_OPENED; LogFlowFunc(("returns %Rrc\n", rc)); return rc; }
RTDECL(void) RTThreadPreemptRestore(PRTTHREADPREEMPTSTATE pState) { AssertPtr(pState); Assert(pState->u32Reserved == 42); pState->u32Reserved = 0; RT_ASSERT_PREEMPT_CPUID_RESTORE(pState); RTCPUID idCpu = RTMpCpuId(); if (RT_UNLIKELY(idCpu < RT_ELEMENTS(g_aPreemptHacks))) { Assert(g_aPreemptHacks[idCpu].cRecursion > 0); if (--g_aPreemptHacks[idCpu].cRecursion == 0) { lck_spin_t *pSpinLock = g_aPreemptHacks[idCpu].pSpinLock; if (pSpinLock) lck_spin_unlock(pSpinLock); else AssertFailed(); } } }
/** @copydoc VBOXHDDBACKEND::pfnSetComment */ static DECLCALLBACK(int) rawSetComment(void *pBackendData, const char *pszComment) { LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment)); PRAWIMAGE pImage = (PRAWIMAGE)pBackendData; int rc; AssertPtr(pImage); if (pImage) { if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY) rc = VERR_VD_IMAGE_READ_ONLY; else rc = VERR_NOT_SUPPORTED; } else rc = VERR_VD_NOT_OPENED; LogFlowFunc(("returns %Rrc\n", rc)); return rc; }
int GuestObject::callbackRemoveAll(void) { int vrc = VINF_SUCCESS; /* * Cancel all callbacks + waiters. * Note: Deleting them is the job of the caller! */ for (GuestCtrlCallbacks::iterator itCallbacks = mObject.mCallbacks.begin(); itCallbacks != mObject.mCallbacks.end(); ++itCallbacks) { GuestCtrlCallback *pCallback = itCallbacks->second; AssertPtr(pCallback); int rc2 = pCallback->Cancel(); if (RT_SUCCESS(vrc)) vrc = rc2; } mObject.mCallbacks.clear(); return vrc; }