void CSteamBase::RunCallbacks() { std::vector<SteamAPIResult_t>::iterator iter; for (iter = _results.begin(); iter < _results.end(); iter++) { SteamAPIResult_t result = *iter; if (_resultHandlers.find(result.call) != _resultHandlers.end()) { _resultHandlers[result.call]->Run(result.data, false, result.call); } std::vector<CCallbackBase*>::iterator cbiter; for (cbiter = _callbacks.begin(); cbiter < _callbacks.end(); cbiter++) { CCallbackBase* cb = *cbiter; if (cb && cb->GetICallback() == result.type) { cb->Run(result.data, false, 0); } } if (result.data) { free(result.data); } } _results.clear(); }
void CallbackManager::RunCallbacks() { CallbackMsg_t callbackMsg; HSteamCall steamCall; //g_Logging.AddToLogFileA("steam_emu.log", "RunCallbacks_i. callbackMsg: %d, steamCall: %d", callbackMsg, steamCall); while( provider.Steam_BGetCallback(NULL, &callbackMsg, &steamCall) ) { currentUser = callbackMsg.m_hSteamUser; int32 callBack = callbackMsg.m_iCallback; ECallbackType type = (ECallbackType)((callBack / 100) * 100); //std::cout << "[DEBUG] Callback: " << callBack << ", Type: " << EnumString<ECallbackType>::From(type) << ", Size: " << callbackMsg.m_cubParam << std::endl; g_Logging.AddToLogFileA( "steam_emu.log", "Callback %d Type %s Size %d", callBack, EnumString<ECallbackType>::From(type).c_str(), callbackMsg.m_cubParam ); if(callbackMsg.m_iCallback == SteamAPICallCompleted_t::k_iCallback) { SteamAPICallCompleted_t *call = (SteamAPICallCompleted_t *)callbackMsg.m_pubParam; RunAPICallbacks(NULL, call); } std::pair<CallbacksMap::iterator, CallbacksMap::iterator> range = callbacks.equal_range(callbackMsg.m_iCallback); for(CallbacksMap::const_iterator iter = range.first; iter != range.second; ++iter) { CCallbackBase *callback = iter->second; if(false && !(callback->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsGameServer)) continue; if(callbackTryCatch) { try { callback->Run(callbackMsg.m_pubParam); } catch(...) {}; } else { callback->Run(callbackMsg.m_pubParam); } } provider.Steam_FreeLastCallback(NULL); } }
void CallbackManager::RunAPICallbacks(HSteamPipe pipe, SteamAPICallCompleted_t *call) { SteamAPICall_t apicall = call->m_hAsyncCall; APICallsMap::const_iterator iter = apicalls.find(apicall); if(iter == apicalls.end()) return; CCallbackBase *callback = iter->second; int size = callback->GetCallbackSizeBytes(); void *data = malloc(size); bool failed = false; bool iok = provider.Steam_GetAPICallResult(pipe, apicall, data, size, callback->GetICallback(), &failed); callback->Run(data, (!iok || failed), apicall); free(data); }