/** * @file llurldispatcher.cpp * @brief Central registry for all URL handlers * * $LicenseInfo:firstyear=2007&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llurldispatcher.h" // viewer includes #include "llagent.h" // teleportViaLocation() #include "llcommandhandler.h" #include "llfloaterhelpbrowser.h" #include "llfloaterreg.h" #include "llfloatersidepanelcontainer.h" #include "llfloaterworldmap.h" #include "llnotifications.h" #include "llpanellogin.h" #include "llregionhandle.h" #include "llslurl.h" #include "llstartup.h" // gStartupState #include "llweb.h" #include "llworldmapmessage.h" #include "llurldispatcherlistener.h" #include "llviewernetwork.h" // library includes #include "llnotificationsutil.h" #include "llsd.h" #include "stringize.h" static LLURLDispatcherListener sURLDispatcherListener; class LLURLDispatcherImpl { public: static bool dispatch(const LLSLURL& slurl, const std::string& nav_type, LLMediaCtrl* web, bool trusted_browser); // returns true if handled or explicitly blocked. static bool dispatchRightClick(const LLSLURL& slurl); private: static bool dispatchCore(const LLSLURL& slurl, const std::string& nav_type, bool right_mouse, LLMediaCtrl* web, bool trusted_browser); // handles both left and right click static bool dispatchHelp(const LLSLURL& slurl, bool right_mouse); // Handles sl://app.floater.html.help by showing Help floater. // Returns true if handled. static bool dispatchApp(const LLSLURL& slurl, const std::string& nav_type, bool right_mouse, LLMediaCtrl* web, bool trusted_browser); // Handles secondlife:///app/agent//about and similar // by showing panel in Search floater. // Returns true if handled or explicitly blocked. static bool dispatchRegion(const LLSLURL& slurl, const std::string& nav_type, bool right_mouse); // handles secondlife://Ahern/123/45/67/ // Returns true if handled. static void regionHandleCallback(U64 handle, const LLSLURL& slurl, const LLUUID& snapshot_id, bool teleport); // Called by LLWorldMap when a location has been resolved to a // region name static void regionNameCallback(U64 handle, const LLSLURL& slurl, const LLUUID& snapshot_id, bool teleport); // Called by LLWorldMap when a region name has been resolved to a // location in-world, used by places-panel display. static bool handleGrid(const LLSLURL& slurl); friend class LLTeleportHandler; }; // static bool LLURLDispatcherImpl::dispatchCore(const LLSLURL& slurl, const std::string& nav_type, bool right_mouse, LLMediaCtrl* web, bool trusted_browser) { //if (dispatchHelp(slurl, right_mouse)) return true; switch(slurl.getType()) { case LLSLURL::APP: return dispatchApp(slurl, nav_type, right_mouse, web, trusted_browser); case LLSLURL::LOCATION: return dispatchRegion(slurl, nav_type, right_mouse); default: return false; } /* // Inform the user we can't handle this std::map args; args["SLURL"] = slurl; r; */ } // static bool LLURLDispatcherImpl::dispatch(const LLSLURL& slurl, const std::string& nav_type, LLMediaCtrl* web, bool trusted_browser) { // SL-20422 : Clicking the "Bring it back" link on Aditi displays a teleport alert // Stop further processing empty urls like [secondlife:/// Bring it back.] if (slurl.getType() == LLSLURL::EMPTY) return true; const bool right_click = false; return dispatchCore(slurl, nav_type, right_click, web, trusted_browser); } // static bool LLURLDispatcherImpl::dispatchRightClick(const LLSLURL& slurl) { const bool right_click = true; LLMediaCtrl* web = NULL; const bool trusted_browser = false; return dispatchCore(slurl, LLCommandHandler::NAV_TYPE_CLICKED, right_click, web, trusted_browser); } // static bool LLURLDispatcherImpl::dispatchApp(const LLSLURL& slurl, const std::string& nav_type, bool right_mouse, LLMediaCtrl* web, bool trusted_browser) { LL_INFOS() << "cmd: " << slurl.getAppCmd() << " path: " << slurl.getAppPath() << " query: " << slurl.getAppQuery() << LL_ENDL; const LLSD& query_map = LLURI::queryMap(slurl.getAppQuery()); bool handled = LLCommandDispatcher::dispatch( slurl.getAppCmd(), slurl.getAppPath(), query_map, slurl.getGrid(), web, nav_type, trusted_browser); // alert if we didn't handle this secondlife:///app/ SLURL // (but still return true because it is a valid app SLURL) if (! handled) { LLNotificationsUtil::add("UnsupportedCommandSLURL"); } return true; } // static bool LLURLDispatcherImpl::dispatchRegion(const LLSLURL& slurl, const std::string& nav_type, bool right_mouse) { if(slurl.getType() != LLSLURL::LOCATION) { return false; } // Before we're logged in, need to update the startup screen // to tell the user where they are going. if (LLStartUp::getStartupState() < STATE_LOGIN_CLEANUP) { // We're at the login screen, so make sure user can see // the login location box to know where they are going. LLPanelLogin::setLocation(slurl); return true; } if (!handleGrid(slurl)) { return true; } // Request a region handle by name LLWorldMapMessage::getInstance()->sendNamedRegionRequest(slurl.getRegion(), LLURLDispatcherImpl::regionNameCallback, slurl.getSLURLString(), LLUI::getInstance()->mSettingGroups["config"]->getBOOL("SLURLTeleportDirectly")); // don't teleport return true; } /*static*/ void LLURLDispatcherImpl::regionNameCallback(U64 region_handle, const LLSLURL& slurl, const LLUUID& snapshot_id, bool teleport) { if(slurl.getType() == LLSLURL::LOCATION) { regionHandleCallback(region_handle, slurl, snapshot_id, teleport); } } bool LLURLDispatcherImpl::handleGrid(const LLSLURL& slurl) { if (LLGridManager::getInstance()->getGrid(slurl.getGrid()) != LLGridManager::getInstance()->getGrid()) { LLSD args; args["SLURL"] = slurl.getLocationString(); args["CURRENT_GRID"] = LLGridManager::getInstance()->getGridLabel(); std::string grid_label = LLGridManager::getInstance()->getGridLabel(slurl.getGrid()); if (!grid_label.empty()) { args["GRID"] = grid_label; } else { args["GRID"] = slurl.getGrid(); } LLNotificationsUtil::add("CantTeleportToGrid", args); return false; } return true; } /* static */ void LLURLDispatcherImpl::regionHandleCallback(U64 region_handle, const LLSLURL& slurl, const LLUUID& snapshot_id, bool teleport) { if (!handleGrid(slurl)) { // we can't teleport cross grid at this point return; } LLVector3d global_pos = from_region_handle(region_handle); global_pos += LLVector3d(slurl.getPosition()); if (teleport) { gAgent.teleportViaLocation(global_pos); LLFloaterWorldMap* instance = LLFloaterWorldMap::getInstance(); if(instance) { instance->trackLocation(global_pos); } } else { LLSD key; key["type"] = "remote_place"; key["x"] = global_pos.mdV[VX]; key["y"] = global_pos.mdV[VY]; key["z"] = global_pos.mdV[VZ]; LLFloaterSidePanelContainer::showPanel("places", key); } } //--------------------------------------------------------------------------- // Teleportation links are handled here because they are tightly coupled // to SLURL parsing and sim-fragment parsing class LLTeleportHandler : public LLCommandHandler, public LLEventAPI { public: // Teleport requests *must* come from a trusted browser // inside the app, otherwise a malicious web page could // cause a constant teleport loop. JC LLTeleportHandler() : LLCommandHandler("teleport", UNTRUSTED_CLICK_ONLY), LLEventAPI("LLTeleportHandler", "Low-level teleport API") { LLEventAPI::add("teleport", "Teleport to specified [\"regionname\"] at\n" "specified region-relative [\"x\"], [\"y\"], [\"z\"].\n" "If [\"regionname\"] is \"home\", ignore [\"x\"], [\"y\"], [\"z\"]\n" "and teleport home.\n" "If [\"regionname\"] omitted, teleport to GLOBAL\n" "coordinates [\"x\"], [\"y\"], [\"z\"].", &LLTeleportHandler::from_event); } bool handle(const LLSD& tokens, const LLSD& query_map, const std::string& grid, LLMediaCtrl* web) { // construct a "normal" SLURL, resolve the region to // a global position, and teleport to it if (tokens.size() < 1) return false; LLVector3 coords(128, 128, 0); if (tokens.size() >= 3) // Require at least [1] and [2] { coords = LLVector3((F32)tokens[1].asReal(), (F32)tokens[2].asReal(), (F32)tokens[3].asReal()); } // Region names may be %20 escaped. std::string region_name = LLURI::unescape(tokens[0]); LLSD args; args["LOCATION"] = region_name; LLSD payload; payload["region_name"] = region_name; payload["callback_url"] = LLSLURL(grid, region_name, coords).getSLURLString(); LLNotificationsUtil::add("TeleportViaSLAPP", args, payload); return true; } void from_event(const LLSD& params) const { Response response(LLSD(), params); if (params["regionname"].asString() == "home") { gAgent.teleportHome(); response["message"] = "Teleporting home"; } else if (params.has("regionname")) { // region specified, coordinates (if any) are region-local LLVector3 local_pos( params.has("x")? (F32)params["x"].asReal() : 128.f, params.has("y")? (F32)params["y"].asReal() : 128.f, params.has("z")? (F32)params["z"].asReal() : 0.f); std::string regionname(params["regionname"]); std::string destination(LLSLURL(regionname, local_pos).getSLURLString()); // have to resolve region's global coordinates first teleport_via_slapp(regionname, destination); response["message"] = "Teleporting to " + destination; } else // no regionname { // coordinates are global, and at least (x, y) are required if (! (params.has("x") && params.has("y"))) { return response.error("Specify either regionname or global (x, y)"); } LLVector3d global_pos(params["x"].asReal(), params["y"].asReal(), params["z"].asReal()); gAgent.teleportViaLocation(global_pos); LLFloaterWorldMap* instance = LLFloaterWorldMap::getInstance(); if (instance) { instance->trackLocation(global_pos); } response["message"] = STRINGIZE("Teleporting to global " << global_pos); } } static void teleport_via_slapp(std::string region_name, std::string callback_url) { LLWorldMapMessage::getInstance()->sendNamedRegionRequest(region_name, LLURLDispatcherImpl::regionHandleCallback, callback_url, true); // teleport } static bool teleport_via_slapp_callback(const LLSD& notification, const LLSD& response) { S32 option = LLNotificationsUtil::getSelectedOption(notification, response); std::string region_name = notification["payload"]["region_name"].asString(); std::string callback_url = notification["payload"]["callback_url"].asString(); if (option == 0) { teleport_via_slapp(region_name, callback_url); return true; } return false; } }; LLTeleportHandler gTeleportHandler; static LLNotificationFunctorRegistration open_landmark_callback_reg("TeleportViaSLAPP", LLTeleportHandler::teleport_via_slapp_callback); //--------------------------------------------------------------------------- // static bool LLURLDispatcher::dispatch(const std::string& slurl, const std::string& nav_type, LLMediaCtrl* web, bool trusted_browser) { return LLURLDispatcherImpl::dispatch(LLSLURL(slurl), nav_type, web, trusted_browser); } // static bool LLURLDispatcher::dispatchRightClick(const std::string& slurl) { return LLURLDispatcherImpl::dispatchRightClick(LLSLURL(slurl)); } // static bool LLURLDispatcher::dispatchFromTextEditor(const std::string& slurl, bool trusted_content) { // *NOTE: Text editors are considered sources of trusted URLs // in order to make avatar profile links in chat history work. // While a malicious resident could chat an app SLURL, the // receiving resident will see it and must affirmatively // click on it. // *TODO: Make this trust model more refined. JC LLMediaCtrl* web = NULL; return LLURLDispatcherImpl::dispatch(LLSLURL(slurl), LLCommandHandler::NAV_TYPE_CLICKED, web, trusted_content); }