llurldispatcher.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:12k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file llurldispatcher.cpp
  3.  * @brief Central registry for all URL handlers
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "llviewerprecompiledheaders.h"
  33. #include "llurldispatcher.h"
  34. // viewer includes
  35. #include "llagent.h" // teleportViaLocation()
  36. #include "llcommandhandler.h"
  37. #include "llfloaterhelpbrowser.h"
  38. #include "llfloaterreg.h"
  39. #include "llfloaterurldisplay.h"
  40. #include "llfloaterworldmap.h"
  41. #include "llpanellogin.h"
  42. #include "llregionhandle.h"
  43. #include "llsidetray.h"
  44. #include "llslurl.h"
  45. #include "llstartup.h" // gStartupState
  46. #include "llurlsimstring.h"
  47. #include "llweb.h"
  48. #include "llworldmapmessage.h"
  49. #include "llurldispatcherlistener.h"
  50. // library includes
  51. #include "llnotificationsutil.h"
  52. #include "llsd.h"
  53. static LLURLDispatcherListener sURLDispatcherListener;
  54. class LLURLDispatcherImpl
  55. {
  56. public:
  57. static bool dispatch(const std::string& url,
  58.  LLMediaCtrl* web,
  59.  bool trusted_browser);
  60. // returns true if handled or explicitly blocked.
  61. static bool dispatchRightClick(const std::string& url);
  62. private:
  63. static bool dispatchCore(const std::string& url, 
  64.  bool right_mouse,
  65.  LLMediaCtrl* web,
  66.  bool trusted_browser);
  67. // handles both left and right click
  68. static bool dispatchHelp(const std::string& url, bool right_mouse);
  69. // Handles sl://app.floater.html.help by showing Help floater.
  70. // Returns true if handled.
  71. static bool dispatchApp(const std::string& url,
  72. bool right_mouse,
  73. LLMediaCtrl* web,
  74. bool trusted_browser);
  75. // Handles secondlife:///app/agent/<agent_id>/about and similar
  76. // by showing panel in Search floater.
  77. // Returns true if handled or explicitly blocked.
  78. static bool dispatchRegion(const std::string& url, bool right_mouse);
  79. // handles secondlife://Ahern/123/45/67/
  80. // Returns true if handled.
  81. static void regionHandleCallback(U64 handle, const std::string& url,
  82. const LLUUID& snapshot_id, bool teleport);
  83. // Called by LLWorldMap when a location has been resolved to a
  84.     // region name
  85. static void regionNameCallback(U64 handle, const std::string& url,
  86. const LLUUID& snapshot_id, bool teleport);
  87. // Called by LLWorldMap when a region name has been resolved to a
  88. // location in-world, used by places-panel display.
  89. friend class LLTeleportHandler;
  90. };
  91. // static
  92. bool LLURLDispatcherImpl::dispatchCore(const std::string& url,
  93.    bool right_mouse,
  94.    LLMediaCtrl* web,
  95.    bool trusted_browser)
  96. {
  97. if (url.empty()) return false;
  98. //if (dispatchHelp(url, right_mouse)) return true;
  99. if (dispatchApp(url, right_mouse, web, trusted_browser)) return true;
  100. if (dispatchRegion(url, right_mouse)) return true;
  101. /*
  102. // Inform the user we can't handle this
  103. std::map<std::string, std::string> args;
  104. args["SLURL"] = url;
  105. r;
  106. */
  107. return false;
  108. }
  109. // static
  110. bool LLURLDispatcherImpl::dispatch(const std::string& url,
  111.    LLMediaCtrl* web,
  112.    bool trusted_browser)
  113. {
  114. llinfos << "url: " << url << llendl;
  115. const bool right_click = false;
  116. return dispatchCore(url, right_click, web, trusted_browser);
  117. }
  118. // static
  119. bool LLURLDispatcherImpl::dispatchRightClick(const std::string& url)
  120. {
  121. llinfos << "url: " << url << llendl;
  122. const bool right_click = true;
  123. LLMediaCtrl* web = NULL;
  124. const bool trusted_browser = false;
  125. return dispatchCore(url, right_click, web, trusted_browser);
  126. }
  127. // static
  128. bool LLURLDispatcherImpl::dispatchApp(const std::string& url, 
  129.   bool right_mouse,
  130.   LLMediaCtrl* web,
  131.   bool trusted_browser)
  132. {
  133. // ensure the URL is in the secondlife:///app/ format
  134. if (!LLSLURL::isSLURLCommand(url))
  135. {
  136. return false;
  137. }
  138. LLURI uri(url);
  139. LLSD pathArray = uri.pathArray();
  140. pathArray.erase(0); // erase "app"
  141. std::string cmd = pathArray.get(0);
  142. pathArray.erase(0); // erase "cmd"
  143. bool handled = LLCommandDispatcher::dispatch(
  144. cmd, pathArray, uri.queryMap(), web, trusted_browser);
  145. // alert if we didn't handle this secondlife:///app/ SLURL
  146. // (but still return true because it is a valid app SLURL)
  147. if (! handled)
  148. {
  149. LLNotificationsUtil::add("UnsupportedCommandSLURL");
  150. }
  151. return true;
  152. }
  153. // static
  154. bool LLURLDispatcherImpl::dispatchRegion(const std::string& url, bool right_mouse)
  155. {
  156. if (!LLSLURL::isSLURL(url))
  157. {
  158. return false;
  159. }
  160. // Before we're logged in, need to update the startup screen
  161. // to tell the user where they are going.
  162. if (LLStartUp::getStartupState() < STATE_LOGIN_CLEANUP)
  163. {
  164. // Parse it and stash in globals, it will be dispatched in
  165. // STATE_CLEANUP.
  166. LLURLSimString::setString(url);
  167. // We're at the login screen, so make sure user can see
  168. // the login location box to know where they are going.
  169. LLPanelLogin::refreshLocation( true );
  170. return true;
  171. }
  172. std::string sim_string = LLSLURL::stripProtocol(url);
  173. std::string region_name;
  174. S32 x = 128;
  175. S32 y = 128;
  176. S32 z = 0;
  177. LLURLSimString::parse(sim_string, &region_name, &x, &y, &z);
  178. // LLFloaterURLDisplay functionality moved to LLPanelPlaces in Side Tray.
  179. //LLFloaterURLDisplay* url_displayp = LLFloaterReg::getTypedInstance<LLFloaterURLDisplay>("preview_url",LLSD());
  180. //if(url_displayp) url_displayp->setName(region_name);
  181. // Request a region handle by name
  182. LLWorldMapMessage::getInstance()->sendNamedRegionRequest(region_name,
  183.   LLURLDispatcherImpl::regionNameCallback,
  184.   url,
  185.   false); // don't teleport
  186. return true;
  187. }
  188. /*static*/
  189. void LLURLDispatcherImpl::regionNameCallback(U64 region_handle, const std::string& url, const LLUUID& snapshot_id, bool teleport)
  190. {
  191. std::string sim_string = LLSLURL::stripProtocol(url);
  192. std::string region_name;
  193. S32 x = 128;
  194. S32 y = 128;
  195. S32 z = 0;
  196. LLURLSimString::parse(sim_string, &region_name, &x, &y, &z);
  197. // Invalid location? EXT-5380
  198. if (!region_handle)
  199. {
  200. if(!region_name.empty() && !LLStringOps::isDigit(region_name.c_str()[0]))// it is no sense to search an empty region_name or when the  region_name  starts with digits
  201. {
  202. // may be an user types incorrect region name, let's help him to find a correct one 
  203. LLFloaterReg::showInstance("search", LLSD().with("category", "places").with("id", LLSD(region_name)));
  204. }
  205. //*TODO: add notification about invalid region_name 
  206. return;
  207. }
  208. LLVector3 local_pos;
  209. local_pos.mV[VX] = (F32)x;
  210. local_pos.mV[VY] = (F32)y;
  211. local_pos.mV[VZ] = (F32)z;
  212. // determine whether the point is in this region
  213. if ((x >= 0) && (x < REGION_WIDTH_UNITS) &&
  214. (y >= 0) && (y < REGION_WIDTH_UNITS))
  215. {
  216. // if so, we're done
  217. regionHandleCallback(region_handle, url, snapshot_id, teleport);
  218. }
  219. else
  220. {
  221. // otherwise find the new region from the location
  222. // add the position to get the new region
  223. LLVector3d global_pos = from_region_handle(region_handle) + LLVector3d(local_pos);
  224. U64 new_region_handle = to_region_handle(global_pos);
  225. LLWorldMapMessage::getInstance()->sendHandleRegionRequest(new_region_handle,
  226.    LLURLDispatcherImpl::regionHandleCallback,
  227.    url, teleport);
  228. }
  229. }
  230. /* static */
  231. void LLURLDispatcherImpl::regionHandleCallback(U64 region_handle, const std::string& url, const LLUUID& snapshot_id, bool teleport)
  232. {
  233. std::string sim_string = LLSLURL::stripProtocol(url);
  234. std::string region_name;
  235. S32 x = 128;
  236. S32 y = 128;
  237. S32 z = 0;
  238. LLURLSimString::parse(sim_string, &region_name, &x, &y, &z);
  239. // remap x and y to local coordinates
  240. S32 local_x = x % REGION_WIDTH_UNITS;
  241. S32 local_y = y % REGION_WIDTH_UNITS;
  242. if (local_x < 0)
  243. local_x += REGION_WIDTH_UNITS;
  244. if (local_y < 0)
  245. local_y += REGION_WIDTH_UNITS;
  246. LLVector3 local_pos;
  247. local_pos.mV[VX] = (F32)local_x;
  248. local_pos.mV[VY] = (F32)local_y;
  249. local_pos.mV[VZ] = (F32)z;
  250. LLVector3d global_pos = from_region_handle(region_handle);
  251. global_pos += LLVector3d(local_pos);
  252. if (teleport)
  253. {
  254. gAgent.teleportViaLocation(global_pos);
  255. LLFloaterWorldMap* instance = LLFloaterWorldMap::getInstance();
  256. if(instance)
  257. {
  258. instance->trackLocation(global_pos);
  259. }
  260. }
  261. else
  262. {
  263. LLSD key;
  264. key["type"] = "remote_place";
  265. key["x"] = global_pos.mdV[VX];
  266. key["y"] = global_pos.mdV[VY];
  267. key["z"] = global_pos.mdV[VZ];
  268. LLSideTray::getInstance()->showPanel("panel_places", key);
  269. // LLFloaterURLDisplay functionality moved to LLPanelPlaces in Side Tray.
  270. // // display informational floater, allow user to click teleport btn
  271. // LLFloaterURLDisplay* url_displayp = LLFloaterReg::getTypedInstance<LLFloaterURLDisplay>("preview_url",LLSD());
  272. // if(url_displayp)
  273. // {
  274. // url_displayp->displayParcelInfo(region_handle, local_pos);
  275. // if(snapshot_id.notNull())
  276. // {
  277. // url_displayp->setSnapshotDisplay(snapshot_id);
  278. // }
  279. // std::string locationString = llformat("%s %d, %d, %d", region_name.c_str(), x, y, z);
  280. // url_displayp->setLocationString(locationString);
  281. // }
  282. }
  283. }
  284. //---------------------------------------------------------------------------
  285. // Teleportation links are handled here because they are tightly coupled
  286. // to URL parsing and sim-fragment parsing
  287. class LLTeleportHandler : public LLCommandHandler
  288. {
  289. public:
  290. // Teleport requests *must* come from a trusted browser
  291. // inside the app, otherwise a malicious web page could
  292. // cause a constant teleport loop.  JC
  293. LLTeleportHandler() : LLCommandHandler("teleport", UNTRUSTED_BLOCK) { }
  294. bool handle(const LLSD& tokens, const LLSD& query_map,
  295. LLMediaCtrl* web)
  296. {
  297. // construct a "normal" SLURL, resolve the region to
  298. // a global position, and teleport to it
  299. if (tokens.size() < 1) return false;
  300. // Region names may be %20 escaped.
  301. std::string region_name = LLURLSimString::unescapeRegionName(tokens[0]);
  302. // build secondlife://De%20Haro/123/45/67 for use in callback
  303. std::string url = LLSLURL::PREFIX_SECONDLIFE;
  304. for (int i = 0; i < tokens.size(); ++i)
  305. {
  306. url += tokens[i].asString() + "/";
  307. }
  308. LLWorldMapMessage::getInstance()->sendNamedRegionRequest(region_name,
  309. LLURLDispatcherImpl::regionHandleCallback,
  310. url,
  311. true); // teleport
  312. return true;
  313. }
  314. };
  315. LLTeleportHandler gTeleportHandler;
  316. //---------------------------------------------------------------------------
  317. // static
  318. bool LLURLDispatcher::dispatch(const std::string& url,
  319.    LLMediaCtrl* web,
  320.    bool trusted_browser)
  321. {
  322. return LLURLDispatcherImpl::dispatch(url, web, trusted_browser);
  323. }
  324. // static
  325. bool LLURLDispatcher::dispatchRightClick(const std::string& url)
  326. {
  327. return LLURLDispatcherImpl::dispatchRightClick(url);
  328. }
  329. // static
  330. bool LLURLDispatcher::dispatchFromTextEditor(const std::string& url)
  331. {
  332. // *NOTE: Text editors are considered sources of trusted URLs
  333. // in order to make avatar profile links in chat history work.
  334. // While a malicious resident could chat an app SLURL, the
  335. // receiving resident will see it and must affirmatively
  336. // click on it.
  337. // *TODO: Make this trust model more refined.  JC
  338. const bool trusted_browser = true;
  339. LLMediaCtrl* web = NULL;
  340. return LLURLDispatcherImpl::dispatch(url, web, trusted_browser);
  341. }