bool LLCommandHandlerRegistry::dispatch(const std::string& cmd, const LLSD& params, const LLSD& query_map, LLMediaCtrl* web, bool trusted_browser) { static bool slurl_blocked = false; static bool slurl_throttled = false; static F64 last_throttle_time = 0.0; F64 cur_time = 0.0; std::map<std::string, LLCommandHandlerInfo>::iterator it = mMap.find(cmd); if (it == mMap.end()) return false; const LLCommandHandlerInfo& info = it->second; if (!trusted_browser) { switch (info.mUntrustedBrowserAccess) { case LLCommandHandler::UNTRUSTED_ALLOW: // fall through and let the command be handled break; case LLCommandHandler::UNTRUSTED_BLOCK: // block request from external browser, but report as // "handled" because it was well formatted. LL_WARNS_ONCE("SLURL") << "Blocked SLURL command from untrusted browser" << LL_ENDL; if (! slurl_blocked) { LLNotificationsUtil::add("BlockedSLURL"); slurl_blocked = true; } return true; case LLCommandHandler::UNTRUSTED_THROTTLE: cur_time = LLTimer::getElapsedSeconds(); if (cur_time < last_throttle_time + THROTTLE_PERIOD) { // block request from external browser if it happened // within THROTTLE_PERIOD secs of the last command LL_WARNS_ONCE("SLURL") << "Throttled SLURL command from untrusted browser" << LL_ENDL; if (! slurl_throttled) { LLNotificationsUtil::add("ThrottledSLURL"); slurl_throttled = true; } return true; } last_throttle_time = cur_time; break; } } if (!info.mHandler) return false; return info.mHandler->handle(params, query_map, web); }
//static std::string LLTrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& msg_args) { // Singu note: make sure LLTrans isn't used in a tight loop. if (sStringTemplates_accesses++ % access_increment == access_increment - 1) log_sStringTemplates_accesses(); template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format_map_t args = sDefaultArgs; args.insert(msg_args.begin(), msg_args.end()); LLStringUtil::format(text, args); return text; } else { LLSD args; args["STRING_NAME"] = xml_desc; LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; LLNotificationsUtil::add("MissingString", args); return "MissingString("+xml_desc+")"; } }
void LLRender::blendFunc(eBlendFactor color_sfactor, eBlendFactor color_dfactor, eBlendFactor alpha_sfactor, eBlendFactor alpha_dfactor) { llassert(color_sfactor < BF_UNDEF); llassert(color_dfactor < BF_UNDEF); llassert(alpha_sfactor < BF_UNDEF); llassert(alpha_dfactor < BF_UNDEF); if (!gGLManager.mHasBlendFuncSeparate) { LL_WARNS_ONCE("render") << "no glBlendFuncSeparateEXT(), using color-only blend func" << llendl; blendFunc(color_sfactor, color_dfactor); return; } if (mCurrBlendColorSFactor != color_sfactor || mCurrBlendColorDFactor != color_dfactor || mCurrBlendAlphaSFactor != alpha_sfactor || mCurrBlendAlphaDFactor != alpha_dfactor) { mCurrBlendColorSFactor = color_sfactor; mCurrBlendAlphaSFactor = alpha_sfactor; mCurrBlendColorDFactor = color_dfactor; mCurrBlendAlphaDFactor = alpha_dfactor; flush(); glBlendFuncSeparateEXT(sGLBlendFactor[color_sfactor], sGLBlendFactor[color_dfactor], sGLBlendFactor[alpha_sfactor], sGLBlendFactor[alpha_dfactor]); } }
//static std::string LLTrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& msg_args) { // Don't care about time as much as call count. Make sure we're not // calling LLTrans::getString() in an inner loop. JC LLFastTimer timer(FTM_GET_TRANS); template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format_map_t args = sDefaultArgs; args.insert(msg_args.begin(), msg_args.end()); LLStringUtil::format(text, args); return text; } else { LLSD args; args["STRING_NAME"] = xml_desc; LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; //LLNotificationsUtil::add("MissingString", args); // *TODO: resurrect //return xml_desc; return "MissingString("+xml_desc+")"; } }
//----------------------------------------------------------------------------- // purgeExcessMotion() //----------------------------------------------------------------------------- void LLMotionController::purgeExcessMotions() { if (mLoadedMotions.size() > MAX_MOTION_INSTANCES) { // clean up deprecated motions for (motion_set_t::iterator deprecated_motion_it = mDeprecatedMotions.begin(); deprecated_motion_it != mDeprecatedMotions.end(); ) { motion_set_t::iterator cur_iter = deprecated_motion_it++; LLMotion* cur_motionp = *cur_iter; if (!isMotionActive(cur_motionp)) { // Motion is deprecated so we know it's not cannonical, // we can safely remove the instance removeMotionInstance(cur_motionp); // modifies mDeprecatedMotions mDeprecatedMotions.erase(cur_iter); } } } std::set<LLUUID> motions_to_kill; if (mLoadedMotions.size() > MAX_MOTION_INSTANCES) { // too many motions active this frame, kill all blenders mPoseBlender.clearBlenders(); for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin(); loaded_motion_it != mLoadedMotions.end(); ++loaded_motion_it) { LLMotion* cur_motionp = *loaded_motion_it; // motion isn't playing, delete it if (!isMotionActive(cur_motionp)) { motions_to_kill.insert(cur_motionp->getID()); } } } // clean up all inactive, loaded motions for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin(); motion_it != motions_to_kill.end(); ++motion_it) { // look up the motion again by ID to get canonical instance // and kill it only if that one is inactive LLUUID motion_id = *motion_it; LLMotion* motionp = findMotion(motion_id); if (motionp && !isMotionActive(motionp)) { removeMotion(motion_id); } } if (mLoadedMotions.size() > 2*MAX_MOTION_INSTANCES) { LL_WARNS_ONCE("Animation") << "> " << 2*MAX_MOTION_INSTANCES << " Loaded Motions" << llendl; } }
//virtual void LLDriverParamInfo::toStream(std::ostream &out) { LLViewerVisualParamInfo::toStream(out); out << "driver" << "\t"; out << mDrivenInfoList.size() << "\t"; for (entry_info_list_t::iterator iter = mDrivenInfoList.begin(); iter != mDrivenInfoList.end(); iter++) { LLDrivenEntryInfo driven = *iter; out << driven.mDrivenID << "\t"; } out << std::endl; // FIXME - this mDriverParam backlink makes no sense, because the // LLDriverParamInfos are static objects - there's only one copy // for each param type, so the backlink will just reference the // corresponding param in the most recently created // avatar. Apparently these toStream() methods are not currently // used anywhere, so it's not an urgent problem. LL_WARNS_ONCE() << "Invalid usage of mDriverParam." << LL_ENDL; if(mDriverParam && mDriverParam->getAvatarAppearance()->isSelf() && mDriverParam->getAvatarAppearance()->isValid()) { for (entry_info_list_t::iterator iter = mDrivenInfoList.begin(); iter != mDrivenInfoList.end(); iter++) { LLDrivenEntryInfo driven = *iter; LLViewerVisualParam *param = (LLViewerVisualParam*)mDriverParam->getAvatarAppearance()->getVisualParam(driven.mDrivenID); if (param) { param->getInfo()->toStream(out); if (param->getWearableType() != mWearableType) { if(param->getCrossWearable()) { out << "cross-wearable" << "\t"; } else { out << "ERROR!" << "\t"; } } else { out << "valid" << "\t"; } } else { LL_WARNS() << "could not get parameter " << driven.mDrivenID << " from avatar " << mDriverParam->getAvatarAppearance() << " for driver parameter " << getID() << LL_ENDL; } out << std::endl; } } }
// // Misc functions // bool ll_apr_warn_status(apr_status_t status) { if(APR_SUCCESS == status) return false; #ifndef LL_WINDOWS char buf[MAX_STRING]; /* Flawfinder: ignore */ LL_WARNS_ONCE("APR") << "APR: " << apr_strerror(status, buf, MAX_STRING) << LL_ENDL; #endif return true; }
F32 LLFeatureList::getRecommendedValue(const std::string& name) { if (mFeatures.count(name) && isFeatureAvailable(name)) { return mFeatures[name].mRecommendedLevel; } LL_WARNS_ONCE("RenderInit") << "Feature " << name << " not on feature list or not available!" << LL_ENDL; return 0; }
BOOL LLFeatureList::isFeatureAvailable(const std::string& name) { if (mFeatures.count(name)) { return mFeatures[name].mAvailable; } LL_WARNS_ONCE("RenderInit") << "Feature " << name << " not on feature list!" << LL_ENDL; // changing this to TRUE so you have to explicitly disable // something for it to be disabled return TRUE; }
//----------------------------------------------------------------------------- // purgeExcessMotion() //----------------------------------------------------------------------------- void LLMotionController::purgeExcessMotions() { //<singu> // The old code attempted to remove non-active motions from mDeprecatedMotions, // but that is nonsense: there are no motions in mDeprecatedMotions that are not active. if (mLoadedMotions.size() <= MAX_MOTION_INSTANCES) { // Speed up, no need to create motions_to_kill. return; } //</singu> std::set<LLUUID> motions_to_kill; if (1) // Singu: leave indentation alone... { // too many motions active this frame, kill all blenders mPoseBlender.clearBlenders(); for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin(); loaded_motion_it != mLoadedMotions.end(); ++loaded_motion_it) { LLMotion* cur_motionp = *loaded_motion_it; // motion isn't playing, delete it if (!isMotionActive(cur_motionp)) { motions_to_kill.insert(cur_motionp->getID()); } } } // clean up all inactive, loaded motions for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin(); motion_it != motions_to_kill.end(); ++motion_it) { // look up the motion again by ID to get canonical instance // and kill it only if that one is inactive LLUUID motion_id = *motion_it; LLMotion* motionp = findMotion(motion_id); if (motionp && !isMotionActive(motionp)) { removeMotion(motion_id); } } if (mLoadedMotions.size() > 2*MAX_MOTION_INSTANCES) { LL_WARNS_ONCE("Animation") << "> " << 2*MAX_MOTION_INSTANCES << " Loaded Motions" << llendl; } }
BOOL LLFeatureList::isFeatureAvailable(const std::string& name) { feature_map_t::iterator iter = mFeatures.find(name); if (iter != mFeatures.end()) { return iter->second.mAvailable; } LL_WARNS_ONCE("RenderInit") << "Feature " << name << " not on feature list!" << LL_ENDL; // changing this to TRUE so you have to explicitly disable // something for it to be disabled return TRUE; }
//static bool LLTrans::findString(std::string &result, const std::string &xml_desc, const LLSD& msg_args) { LLFastTimer timer(FTM_GET_TRANS); template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format(text, msg_args); result = text; return true; } else { LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; return false; } }
//static std::string LLTrans::getString(const std::string &xml_desc, const LLSD& msg_args) { // Don't care about time as much as call count. Make sure we're not // calling LLTrans::getString() in an inner loop. JC LLFastTimer timer(FTM_GET_TRANS); template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format(text, msg_args); return text; } else { LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; return "MissingString("+xml_desc+")"; } }
//static bool LLTrans::findString(std::string &result, const std::string &xml_desc, const LLSD& msg_args) { // Singu note: make sure LLTrans isn't used in a tight loop. if (sStringTemplates_accesses++ % access_increment == 0) log_sStringTemplates_accesses(); template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format(text, msg_args); result = text; return true; } else { LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; return false; } }
bool LLCommandHandlerRegistry::dispatch(const std::string& cmd, const LLSD& params, const LLSD& query_map, LLMediaCtrl* web, bool trusted_browser) { std::map<std::string, LLCommandHandlerInfo>::iterator it = mMap.find(cmd); if (it == mMap.end()) return false; const LLCommandHandlerInfo& info = it->second; if (!trusted_browser && info.mRequireTrustedBrowser) { // block request from external browser, but report as // "handled" because it was well formatted. LL_WARNS_ONCE("IZURL") << "Blocked IZURL command from untrusted browser" << LL_ENDL; return true; } if (!info.mHandler) return false; return info.mHandler->handle(params, query_map, web); }
void LLDrawable::makeStatic(BOOL warning_enabled) { if (isState(ACTIVE)) { clearState(ACTIVE); gPipeline.setActive(this, FALSE); if (mParent.notNull() && mParent->isActive() && warning_enabled) { LL_WARNS_ONCE("Drawable") << "Drawable becomes static with active parent!" << LL_ENDL; } LLViewerObject::const_child_list_t& child_list = mVObjp->getChildren(); for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin(); iter != child_list.end(); iter++) { LLViewerObject* child = *iter; LLDrawable* child_drawable = child->mDrawable; if (child_drawable) { if (child_drawable->getParent() != this) { llwarns << "Child drawable has unknown parent." << llendl; } child_drawable->makeStatic(warning_enabled); } } if (mVObjp->getPCode() == LL_PCODE_VOLUME) { gPipeline.markRebuild(this, LLDrawable::REBUILD_VOLUME, TRUE); } if (mSpatialBridge) { mSpatialBridge->markDead(); setSpatialBridge(NULL); } } updatePartition(); }
//static std::string LLTrans::getString(const std::string &xml_desc, const LLSD& msg_args) { // Singu note: make sure LLTrans isn't used in a tight loop. if (sStringTemplates_accesses++ % access_increment == 0) log_sStringTemplates_accesses(); // Since sStringTemplates is read-only after it's initial initialization during start up, // this function is already thread-safe. template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format(text, msg_args); return text; } else { LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; return "MissingString("+xml_desc+")"; } }
//static std::string LLUITrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& args) { template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format(text, args); return text; } else { LLSD args; args["STRING_NAME"] = xml_desc; LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; LLNotifications::instance().add("MissingString", args); return xml_desc; } }
//static bool LLTrans::findString(std::string &result, const std::string &xml_desc, const LLStringUtil::format_map_t& msg_args) { LLFastTimer timer(FTM_GET_TRANS); template_map_t::iterator iter = sStringTemplates.find(xml_desc); if (iter != sStringTemplates.end()) { std::string text = iter->second.mText; LLStringUtil::format_map_t args = sDefaultArgs; args.insert(msg_args.begin(), msg_args.end()); LLStringUtil::format(text, args); result = text; return true; } else { LLSD args; args["STRING_NAME"] = xml_desc; LL_WARNS_ONCE("configuration") << "Missing String in strings.xml: [" << xml_desc << "]" << LL_ENDL; //LLNotificationsUtil::add("MissingString", args); return false; } }
void LLAvatarNameCache::idle() { // By convention, start running at first idle() call sRunning = true; // *TODO: Possibly re-enabled this based on People API load measurements // 100 ms is the threshold for "user speed" operations, so we can // stall for about that long to batch up requests. const F32 SECS_BETWEEN_REQUESTS = 0.1f; if (!sRequestTimer.hasExpired()) { return; } if (!sAskQueue.empty()) { if (usePeopleAPI()) { requestNamesViaCapability(); } else { LL_WARNS_ONCE("AvNameCache") << "LLAvatarNameCache still using legacy api" << LL_ENDL; requestNamesViaLegacy(); } } if (sAskQueue.empty()) { // cleared the list, reset the request timer. sRequestTimer.resetWithExpiry(SECS_BETWEEN_REQUESTS); } // erase anything that has not been refreshed for more than MAX_UNREFRESHED_TIME eraseUnrefreshed(); }
bool LLLoginHandler::handle(const LLSD& tokens, const LLSD& query_map, LLMediaCtrl* web) { // do nothing if we are already logged in if (LLLoginInstance::getInstance()->authSuccess()) { LL_WARNS_ONCE("SLURL") << "Already logged in! Ignoring login SLapp." << LL_ENDL; return true; } if (tokens.size() == 1 && tokens[0].asString() == "show") { // We're using reg-in-client, so show the XUI login widgets LLPanelLogin::showLoginWidgets(); return true; } if (tokens.size() == 1 && tokens[0].asString() == "reg") { LLWindow* window = gViewerWindow->getWindow(); window->incBusyCount(); window->setCursor(UI_CURSOR_ARROW); // Do this first, as it may be slow and we want to keep something // on the user's screen as long as possible LLWeb::loadURLExternal( "http://join.eniac15.lindenlab.com/" ); window->decBusyCount(); window->setCursor(UI_CURSOR_ARROW); // Then hide the window window->minimize(); return true; } // Make sure window is visible LLWindow* window = gViewerWindow->getWindow(); if (window->getMinimized()) { window->restore(); } parse(query_map); //if we haven't initialized stuff yet, this is //coming in from the GURL handler, just parse if (STATE_FIRST == LLStartUp::getStartupState()) { return true; } if (LLStartUp::getStartupState() < STATE_LOGIN_CLEANUP) //on splash page { // as the login page may change from grid to grid, as well as // things like username/password/etc, we simply refresh the // login page to make sure everything is set up correctly LLPanelLogin::loadLoginPage(); LLStartUp::setStartupState( STATE_LOGIN_CLEANUP ); } return true; }
// Give libcurl some cycles, invoke it's callbacks, process // completed requests finalizing or issuing retries as needed. // // If active list goes empty *and* we didn't queue any // requests for retry, we return a request for a hard // sleep otherwise ask for a normal polling interval. HttpService::ELoopSpeed HttpLibcurl::processTransport() { HttpService::ELoopSpeed ret(HttpService::REQUEST_SLEEP); // Give libcurl some cycles to do I/O & callbacks for (int policy_class(0); policy_class < mPolicyCount; ++policy_class) { if (! mMultiHandles[policy_class]) { // No handle, nothing to do. continue; } if (! mActiveHandles[policy_class]) { // If we've gone quiet and there's a dirty update, apply it, // otherwise we're done. if (mDirtyPolicy[policy_class]) { policyUpdated(policy_class); } continue; } int running(0); CURLMcode status(CURLM_CALL_MULTI_PERFORM); do { running = 0; status = curl_multi_perform(mMultiHandles[policy_class], &running); } while (0 != running && CURLM_CALL_MULTI_PERFORM == status); // Run completion on anything done CURLMsg * msg(NULL); int msgs_in_queue(0); while ((msg = curl_multi_info_read(mMultiHandles[policy_class], &msgs_in_queue))) { if (CURLMSG_DONE == msg->msg) { CURL * handle(msg->easy_handle); CURLcode result(msg->data.result); completeRequest(mMultiHandles[policy_class], handle, result); handle = NULL; // No longer valid on return ret = HttpService::NORMAL; // If anything completes, we may have a free slot. // Turning around quickly reduces connection gap by 7-10mS. } else if (CURLMSG_NONE == msg->msg) { // Ignore this... it shouldn't mean anything. ; } else { LL_WARNS_ONCE(LOG_CORE) << "Unexpected message from libcurl. Msg code: " << msg->msg << LL_ENDL; } msgs_in_queue = 0; } } if (! mActiveOps.empty()) { ret = HttpService::NORMAL; } return ret; }