开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llstartup.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：97k
源码类别：

游戏引擎

开发平台：

C++ Builder

llstartup.cpp：源码内容
  1. /** 
  2.  * @file llstartup.cpp
  3.  * @brief startup routines.
  4.  *
  5.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2004-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.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llstartup.h"
  37. #if LL_WINDOWS
  38. # include <process.h> // _spawnl()
  39. #else
  40. # include <sys/stat.h> // mkdir()
  41. #endif
  43. #include "llviewermedia_streamingaudio.h"
  44. #include "llaudioengine.h"
  46. #ifdef LL_FMOD
  47. # include "llaudioengine_fmod.h"
  48. #endif
  50. #ifdef LL_OPENAL
  51. #include "llaudioengine_openal.h"
  52. #endif
  54. #include "llares.h"
  55. #include "lllandmark.h"
  56. #include "llcachename.h"
  57. #include "lldir.h"
  58. #include "llerrorcontrol.h"
  59. #include "llfloaterreg.h"
  60. #include "llfocusmgr.h"
  61. #include "llhttpsender.h"
  62. #include "llimfloater.h"
  63. #include "lllocationhistory.h"
  64. #include "llimageworker.h"
  65. #include "llloginflags.h"
  66. #include "llmd5.h"
  67. #include "llmemorystream.h"
  68. #include "llmessageconfig.h"
  69. #include "llmoveview.h"
  70. #include "llnearbychat.h"
  71. #include "llnotifications.h"
  72. #include "llnotificationsutil.h"
  73. #include "llteleporthistory.h"
  74. #include "llregionhandle.h"
  75. #include "llsd.h"
  76. #include "llsdserialize.h"
  77. #include "llsdutil_math.h"
  78. #include "llsecondlifeurls.h"
  79. #include "llstring.h"
  80. #include "lluserrelations.h"
  81. #include "llversioninfo.h"
  82. #include "llviewercontrol.h"
  83. #include "llvfs.h"
  84. #include "llxorcipher.h" // saved password, MAC address
  85. #include "llwindow.h"
  86. #include "imageids.h"
  87. #include "message.h"
  88. #include "v3math.h"
  90. #include "llagent.h"
  91. #include "llagentpicksinfo.h"
  92. #include "llagentwearables.h"
  93. #include "llagentpilot.h"
  94. #include "llfloateravatarpicker.h"
  95. #include "llcallbacklist.h"
  96. #include "llcallingcard.h"
  97. #include "llconsole.h"
  98. #include "llcontainerview.h"
  99. #include "lldebugview.h"
  100. #include "lldrawable.h"
  101. #include "lleventnotifier.h"
  102. #include "llface.h"
  103. #include "llfeaturemanager.h"
  104. //#include "llfirstuse.h"
  105. #include "llfloaterhud.h"
  106. #include "llfloaterland.h"
  107. #include "llfloaterpreference.h"
  108. #include "llfloatertopobjects.h"
  109. #include "llfloaterworldmap.h"
  110. #include "llgesturemgr.h"
  111. #include "llgroupmgr.h"
  112. #include "llhudeffecttrail.h"
  113. #include "llhudmanager.h"
  114. #include "llhttpclient.h"
  115. #include "llimagebmp.h"
  116. #include "llinventorybridge.h"
  117. #include "llinventorymodel.h"
  118. #include "llfriendcard.h"
  119. #include "llkeyboard.h"
  120. #include "llloginhandler.h" // gLoginHandler, SLURL support
  121. #include "lllogininstance.h" // Host the login module.
  122. #include "llpanellogin.h"
  123. #include "llmutelist.h"
  124. #include "llpanelavatar.h"
  125. #include "llavatarpropertiesprocessor.h"
  126. #include "llfloaterevent.h"
  127. #include "llpanelclassified.h"
  128. #include "llpanelpick.h"
  129. #include "llpanelplace.h"
  130. #include "llpanelgrouplandmoney.h"
  131. #include "llpanelgroupnotices.h"
  132. #include "llpreview.h"
  133. #include "llpreviewscript.h"
  134. #include "llproductinforequest.h"
  135. #include "llsecondlifeurls.h"
  136. #include "llselectmgr.h"
  137. #include "llsky.h"
  138. #include "llsidetray.h"
  139. #include "llstatview.h"
  140. #include "llstatusbar.h" // sendMoneyBalanceRequest(), owns L$ balance
  141. #include "llsurface.h"
  142. #include "lltexturecache.h"
  143. #include "lltexturefetch.h"
  144. #include "lltoolmgr.h"
  145. #include "lltrans.h"
  146. #include "llui.h"
  147. #include "llurldispatcher.h"
  148. #include "llurlsimstring.h"
  149. #include "llurlhistory.h"
  150. #include "llurlwhitelist.h"
  151. #include "llvieweraudio.h"
  152. #include "llviewerassetstorage.h"
  153. #include "llviewercamera.h"
  154. #include "llviewerdisplay.h"
  155. #include "llviewergenericmessage.h"
  156. #include "llviewergesture.h"
  157. #include "llviewertexturelist.h"
  158. #include "llviewermedia.h"
  159. #include "llviewermenu.h"
  160. #include "llviewermessage.h"
  161. #include "llviewernetwork.h"
  162. #include "llviewerobjectlist.h"
  163. #include "llviewerparcelmedia.h"
  164. #include "llviewerparcelmgr.h"
  165. #include "llviewerregion.h"
  166. #include "llviewerstats.h"
  167. #include "llviewerthrottle.h"
  168. #include "llviewerwindow.h"
  169. #include "llvoavatar.h"
  170. #include "llvoavatarself.h"
  171. #include "llvoclouds.h"
  172. #include "llweb.h"
  173. #include "llworld.h"
  174. #include "llworldmapmessage.h"
  175. #include "llxfermanager.h"
  176. #include "pipeline.h"
  177. #include "llappviewer.h"
  178. #include "llfasttimerview.h"
  179. #include "llfloatermap.h"
  180. #include "llweb.h"
  181. #include "llvoiceclient.h"
  182. #include "llnamelistctrl.h"
  183. #include "llnamebox.h"
  184. #include "llnameeditor.h"
  185. #include "llpostprocess.h"
  186. #include "llwlparammanager.h"
  187. #include "llwaterparammanager.h"
  188. #include "llagentlanguage.h"
  189. #include "llwearable.h"
  190. #include "llinventorybridge.h"
  191. #include "llappearancemgr.h"
  192. #include "llavatariconctrl.h"
  194. #include "lllogin.h"
  195. #include "llevents.h"
  196. #include "llstartuplistener.h"
  198. #if LL_WINDOWS
  199. #include "llwindebug.h"
  200. #include "lldxhardware.h"
  201. #endif
  203. #if (LL_LINUX || LL_SOLARIS) && LL_GTK
  204. #include <glib/gspawn.h>
  205. #endif
  207. //
  208. // exported globals
  209. //
  210. bool gAgentMovementCompleted = false;
  212. std::string SCREEN_HOME_FILENAME = "screen_home.bmp";
  213. std::string SCREEN_LAST_FILENAME = "screen_last.bmp";
  215. LLPointer<LLViewerTexture> gStartTexture;
  217. //
  218. // Imported globals
  219. //
  220. extern S32 gStartImageWidth;
  221. extern S32 gStartImageHeight;
  223. //
  224. // local globals
  225. //
  226. static bool gGotUseCircuitCodeAck = false;
  227. static std::string sInitialOutfit;
  228. static std::string sInitialOutfitGender; // "male" or "female"
  230. static bool gUseCircuitCallbackCalled = false;
  232. EStartupState LLStartUp::gStartupState = STATE_FIRST;
  234. // *NOTE:Mani - to reconcile with giab changes...
  235. static std::string gFirstname;
  236. static std::string gLastname;
  237. static std::string gPassword;
  239. static U64 gFirstSimHandle = 0;
  240. static LLHost gFirstSim;
  241. static std::string gFirstSimSeedCap;
  242. static LLVector3 gAgentStartLookAt(1.0f, 0.f, 0.f);
  243. static std::string gAgentStartLocation = "safe";
  245. boost::scoped_ptr<LLEventPump> LLStartUp::sStateWatcher(new LLEventStream("StartupState"));
  246. boost::scoped_ptr<LLStartupListener> LLStartUp::sListener(new LLStartupListener());
  248. //
  249. // local function declaration
  250. //
  252. void login_show();
  253. void login_callback(S32 option, void* userdata);
  254. bool is_hex_string(U8* str, S32 len);
  255. void show_first_run_dialog();
  256. bool first_run_dialog_callback(const LLSD& notification, const LLSD& response);
  257. void set_startup_status(const F32 frac, const std::string& string, const std::string& msg);
  258. bool login_alert_status(const LLSD& notification, const LLSD& response);
  259. void login_packet_failed(void**, S32 result);
  260. void use_circuit_callback(void**, S32 result);
  261. void register_viewer_callbacks(LLMessageSystem* msg);
  262. void asset_callback_nothing(LLVFS*, const LLUUID&, LLAssetType::EType, void*, S32);
  263. bool callback_choose_gender(const LLSD& notification, const LLSD& response);
  264. void init_start_screen(S32 location_id);
  265. void release_start_screen();
  266. void reset_login();
  267. void apply_udp_blacklist(const std::string& csv);
  268. bool process_login_success_response();
  269. void transition_back_to_login_panel(const std::string& emsg);
  271. void callback_cache_name(const LLUUID& id, const std::string& firstname, const std::string& lastname, BOOL is_group)
  272. {
  273. LLNameListCtrl::refreshAll(id, firstname, lastname, is_group);
  274. LLNameBox::refreshAll(id, firstname, lastname, is_group);
  275. LLNameEditor::refreshAll(id, firstname, lastname, is_group);
  277. // TODO: Actually be intelligent about the refresh.
  278. // For now, just brute force refresh the dialogs.
  279. dialog_refresh_all();
  280. }
  282. //
  283. // exported functionality
  284. //
  286. //
  287. // local classes
  288. //
  290. namespace
  291. {
  292. class LLNullHTTPSender : public LLHTTPSender
  293. {
  294. virtual void send(const LLHost& host, 
  295.   const std::string& message, const LLSD& body, 
  296.   LLHTTPClient::ResponderPtr response) const
  297. {
  298. LL_WARNS("AppInit") << " attemped to send " << message << " to " << host
  299. << " with null sender" << LL_ENDL;
  300. }
  301. };
  302. }
  304. void update_texture_fetch()
  305. {
  306. LLAppViewer::getTextureCache()->update(1); // unpauses the texture cache thread
  307. LLAppViewer::getImageDecodeThread()->update(1); // unpauses the image thread
  308. LLAppViewer::getTextureFetch()->update(1); // unpauses the texture fetch thread
  309. gTextureList.updateImages(0.10f);
  310. }
  312. // Returns false to skip other idle processing. Should only return
  313. // true when all initialization done.
  314. bool idle_startup()
  315. {
  316. LLMemType mt1(LLMemType::MTYPE_STARTUP);
  318. const F32 PRECACHING_DELAY = gSavedSettings.getF32("PrecachingDelay");
  319. static LLTimer timeout;
  320. static S32 timeout_count = 0;
  322. static LLTimer login_time;
  324. // until this is encapsulated, this little hack for the
  325. // auth/transform loop will do.
  326. static F32 progress = 0.10f;
  328. static std::string auth_desc;
  329. static std::string auth_message;
  331. static LLVector3 initial_sun_direction(1.f, 0.f, 0.f);
  332. static LLVector3 agent_start_position_region(10.f, 10.f, 10.f); // default for when no space server
  334. // last location by default
  335. static S32  agent_location_id = START_LOCATION_ID_LAST;
  336. static S32  location_which = START_LOCATION_ID_LAST;
  338. static bool show_connect_box = true;
  340. //static bool stipend_since_login = false;
  342. // HACK: These are things from the main loop that usually aren't done
  343. // until initialization is complete, but need to be done here for things
  344. // to work.
  345. gIdleCallbacks.callFunctions();
  346. gViewerWindow->updateUI();
  347. LLMortician::updateClass();
  349. const std::string delims (" ");
  350. std::string system;
  351. int begIdx, endIdx;
  352. std::string osString = LLAppViewer::instance()->getOSInfo().getOSStringSimple();
  354. begIdx = osString.find_first_not_of (delims);
  355. endIdx = osString.find_first_of (delims, begIdx);
  356. system = osString.substr (begIdx, endIdx - begIdx);
  357. system += "Locale";
  359. LLStringUtil::setLocale (LLTrans::getString(system));
  361. if (!gNoRender)
  362. {
  363. //note: Removing this line will cause incorrect button size in the login screen. -- bao.
  364. gTextureList.updateImages(0.01f) ;
  365. }
  367. if ( STATE_FIRST == LLStartUp::getStartupState() )
  368. {
  369. gViewerWindow->showCursor();
  370. gViewerWindow->getWindow()->setCursor(UI_CURSOR_WAIT);
  372. /////////////////////////////////////////////////
  373. //
  374. // Initialize stuff that doesn't need data from simulators
  375. //
  377. if (LLFeatureManager::getInstance()->isSafe())
  378. {
  379. LLNotificationsUtil::add("DisplaySetToSafe");
  380. }
  381. else if ((gSavedSettings.getS32("LastFeatureVersion") < LLFeatureManager::getInstance()->getVersion()) &&
  382.  (gSavedSettings.getS32("LastFeatureVersion") != 0))
  383. {
  384. LLNotificationsUtil::add("DisplaySetToRecommended");
  385. }
  386. else if (!gViewerWindow->getInitAlert().empty())
  387. {
  388. LLNotificationsUtil::add(gViewerWindow->getInitAlert());
  389. }
  391. gSavedSettings.setS32("LastFeatureVersion", LLFeatureManager::getInstance()->getVersion());
  393. std::string xml_file = LLUI::locateSkin("xui_version.xml");
  394. LLXMLNodePtr root;
  395. bool xml_ok = false;
  396. if (LLXMLNode::parseFile(xml_file, root, NULL))
  397. {
  398. if( (root->hasName("xui_version") ) )
  399. {
  400. std::string value = root->getValue();
  401. F32 version = 0.0f;
  402. LLStringUtil::convertToF32(value, version);
  403. if (version >= 1.0f)
  404. {
  405. xml_ok = true;
  406. }
  407. }
  408. }
  409. if (!xml_ok)
  410. {
  411. // If XML is bad, there's a good possibility that notifications.xml is ALSO bad.
  412. // If that's so, then we'll get a fatal error on attempting to load it, 
  413. // which will display a nontranslatable error message that says so.
  414. // Otherwise, we'll display a reasonable error message that IS translatable.
  415. LLAppViewer::instance()->earlyExit("BadInstallation");
  416. }
  417. //
  418. // Statistics stuff
  419. //
  421. // Load autopilot and stats stuff
  422. gAgentPilot.load(gSavedSettings.getString("StatsPilotFile"));
  424. //gErrorStream.setTime(gSavedSettings.getBOOL("LogTimestamps"));
  426. // Load the throttle settings
  427. gViewerThrottle.load();
  429. if (ll_init_ares() == NULL || !gAres->isInitialized())
  430. {
  431. std::string diagnostic = "Could not start address resolution system";
  432. LL_WARNS("AppInit") << diagnostic << LL_ENDL;
  433. LLAppViewer::instance()->earlyExit("LoginFailedNoNetwork", LLSD().with("DIAGNOSTIC", diagnostic));
  434. }
  436. //
  437. // Initialize messaging system
  438. //
  439. LL_DEBUGS("AppInit") << "Initializing messaging system..." << LL_ENDL;
  441. std::string message_template_path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"message_template.msg");
  443. LLFILE* found_template = NULL;
  444. found_template = LLFile::fopen(message_template_path, "r"); /* Flawfinder: ignore */
  446. #if LL_WINDOWS
  447. // On the windows dev builds, unpackaged, the message_template.msg 
  448. // file will be located in:
  449. // build-vc**/newview/<config>/app_settings
  450. if (!found_template)
  451. {
  452. message_template_path = gDirUtilp->getExpandedFilename(LL_PATH_EXECUTABLE, "app_settings", "message_template.msg");
  453. found_template = LLFile::fopen(message_template_path.c_str(), "r"); /* Flawfinder: ignore */
  454. }
  455. #elif LL_DARWIN
  456. // On Mac dev builds, message_template.msg lives in:
  457. // indra/build-*/newview/<config>/Second Life/Contents/Resources/app_settings
  458. if (!found_template)
  459. {
  460. message_template_path =
  461. gDirUtilp->getExpandedFilename(LL_PATH_EXECUTABLE,
  462.    "../Resources/app_settings",
  463.    "message_template.msg");
  464. found_template = LLFile::fopen(message_template_path.c_str(), "r"); /* Flawfinder: ignore */
  465. }
  466. #endif
  468. if (found_template)
  469. {
  470. fclose(found_template);
  472. U32 port = gSavedSettings.getU32("UserConnectionPort");
  474. if ((NET_USE_OS_ASSIGNED_PORT == port) &&   // if nothing specified on command line (-port)
  475.     (gSavedSettings.getBOOL("ConnectionPortEnabled")))
  476.   {
  477.     port = gSavedSettings.getU32("ConnectionPort");
  478.   }
  480. LLHTTPSender::setDefaultSender(new LLNullHTTPSender());
  482. // TODO parameterize 
  483. const F32 circuit_heartbeat_interval = 5;
  484. const F32 circuit_timeout = 100;
  486. const LLUseCircuitCodeResponder* responder = NULL;
  487. bool failure_is_fatal = true;
  489. if(!start_messaging_system(
  490.    message_template_path,
  491.    port,
  492.    LLVersionInfo::getMajor(),
  493.    LLVersionInfo::getMinor(),
  494.    LLVersionInfo::getPatch(),
  495.    FALSE,
  496.    std::string(),
  497.    responder,
  498.    failure_is_fatal,
  499.    circuit_heartbeat_interval,
  500.    circuit_timeout))
  501. {
  502. std::string diagnostic = llformat(" Error: %d", gMessageSystem->getErrorCode());
  503. LL_WARNS("AppInit") << diagnostic << LL_ENDL;
  504. LLAppViewer::instance()->earlyExit("LoginFailedNoNetwork", LLSD().with("DIAGNOSTIC", diagnostic));
  505. }
  507. #if LL_WINDOWS
  508. // On the windows dev builds, unpackaged, the message.xml file will 
  509. // be located in indra/build-vc**/newview/<config>/app_settings.
  510. std::string message_path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"message.xml");
  512. if (!LLFile::isfile(message_path.c_str())) 
  513. {
  514. LLMessageConfig::initClass("viewer", gDirUtilp->getExpandedFilename(LL_PATH_EXECUTABLE, "app_settings", ""));
  515. }
  516. else
  517. {
  518. LLMessageConfig::initClass("viewer", gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
  519. }
  520. #else
  521. LLMessageConfig::initClass("viewer", gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
  522. #endif
  524. }
  525. else
  526. {
  527. LLAppViewer::instance()->earlyExit("MessageTemplateNotFound", LLSD().with("PATH", message_template_path));
  528. }
  530. if(gMessageSystem && gMessageSystem->isOK())
  531. {
  532. // Initialize all of the callbacks in case of bad message
  533. // system data
  534. LLMessageSystem* msg = gMessageSystem;
  535. msg->setExceptionFunc(MX_UNREGISTERED_MESSAGE,
  536.   invalid_message_callback,
  537.   NULL);
  538. msg->setExceptionFunc(MX_PACKET_TOO_SHORT,
  539.   invalid_message_callback,
  540.   NULL);
  542. // running off end of a packet is now valid in the case
  543. // when a reader has a newer message template than
  544. // the sender
  545. /*msg->setExceptionFunc(MX_RAN_OFF_END_OF_PACKET,
  546.   invalid_message_callback,
  547.   NULL);*/
  548. msg->setExceptionFunc(MX_WROTE_PAST_BUFFER_SIZE,
  549.   invalid_message_callback,
  550.   NULL);
  552. if (gSavedSettings.getBOOL("LogMessages"))
  553. {
  554. LL_DEBUGS("AppInit") << "Message logging activated!" << LL_ENDL;
  555. msg->startLogging();
  556. }
  558. // start the xfer system. by default, choke the downloads
  559. // a lot...
  560. const S32 VIEWER_MAX_XFER = 3;
  561. start_xfer_manager(gVFS);
  562. gXferManager->setMaxIncomingXfers(VIEWER_MAX_XFER);
  563. F32 xfer_throttle_bps = gSavedSettings.getF32("XferThrottle");
  564. if (xfer_throttle_bps > 1.f)
  565. {
  566. gXferManager->setUseAckThrottling(TRUE);
  567. gXferManager->setAckThrottleBPS(xfer_throttle_bps);
  568. }
  569. gAssetStorage = new LLViewerAssetStorage(msg, gXferManager, gVFS);
  572. F32 dropPercent = gSavedSettings.getF32("PacketDropPercentage");
  573. msg->mPacketRing.setDropPercentage(dropPercent);
  575.             F32 inBandwidth = gSavedSettings.getF32("InBandwidth"); 
  576.             F32 outBandwidth = gSavedSettings.getF32("OutBandwidth"); 
  577. if (inBandwidth != 0.f)
  578. {
  579. LL_DEBUGS("AppInit") << "Setting packetring incoming bandwidth to " << inBandwidth << LL_ENDL;
  580. msg->mPacketRing.setUseInThrottle(TRUE);
  581. msg->mPacketRing.setInBandwidth(inBandwidth);
  582. }
  583. if (outBandwidth != 0.f)
  584. {
  585. LL_DEBUGS("AppInit") << "Setting packetring outgoing bandwidth to " << outBandwidth << LL_ENDL;
  586. msg->mPacketRing.setUseOutThrottle(TRUE);
  587. msg->mPacketRing.setOutBandwidth(outBandwidth);
  588. }
  589. }
  591. LL_INFOS("AppInit") << "Message System Initialized." << LL_ENDL;
  593. //-------------------------------------------------
  594. // Init audio, which may be needed for prefs dialog
  595. // or audio cues in connection UI.
  596. //-------------------------------------------------
  598. if (FALSE == gSavedSettings.getBOOL("NoAudio"))
  599. {
  600. gAudiop = NULL;
  602. #ifdef LL_OPENAL
  603. if (!gAudiop
  604. #if !LL_WINDOWS
  605.     && NULL == getenv("LL_BAD_OPENAL_DRIVER")
  606. #endif // !LL_WINDOWS
  607.     )
  608. {
  609. gAudiop = (LLAudioEngine *) new LLAudioEngine_OpenAL();
  610. }
  611. #endif
  613. #ifdef LL_FMOD
  614. if (!gAudiop
  615. #if !LL_WINDOWS
  616.     && NULL == getenv("LL_BAD_FMOD_DRIVER")
  617. #endif // !LL_WINDOWS
  618.     )
  619. {
  620. gAudiop = (LLAudioEngine *) new LLAudioEngine_FMOD();
  621. }
  622. #endif
  624. if (gAudiop)
  625. {
  626. #if LL_WINDOWS
  627. // FMOD on Windows needs the window handle to stop playing audio
  628. // when window is minimized. JC
  629. void* window_handle = (HWND)gViewerWindow->getPlatformWindow();
  630. #else
  631. void* window_handle = NULL;
  632. #endif
  633. bool init = gAudiop->init(kAUDIO_NUM_SOURCES, window_handle);
  634. if(init)
  635. {
  636. gAudiop->setMuted(TRUE);
  637. }
  638. else
  639. {
  640. LL_WARNS("AppInit") << "Unable to initialize audio engine" << LL_ENDL;
  641. delete gAudiop;
  642. gAudiop = NULL;
  643. }
  645. if (gAudiop)
  646. {
  647. // if the audio engine hasn't set up its own preferred handler for streaming audio then set up the generic streaming audio implementation which uses media plugins
  648. if (NULL == gAudiop->getStreamingAudioImpl())
  649. {
  650. LL_INFOS("AppInit") << "Using media plugins to render streaming audio" << LL_ENDL;
  651. gAudiop->setStreamingAudioImpl(new LLStreamingAudio_MediaPlugins());
  652. }
  653. }
  654. }
  655. }
  657. LL_INFOS("AppInit") << "Audio Engine Initialized." << LL_ENDL;
  659. if (LLTimer::knownBadTimer())
  660. {
  661. LL_WARNS("AppInit") << "Unreliable timers detected (may be bad PCI chipset)!!" << LL_ENDL;
  662. }
  664. //
  665. // Log on to system
  666. //
  667. if (!LLStartUp::sSLURLCommand.empty())
  668. {
  669. // this might be a secondlife:///app/login URL
  670. gLoginHandler.parseDirectLogin(LLStartUp::sSLURLCommand);
  671. }
  672. if (!gLoginHandler.getFirstName().empty()
  673. || !gLoginHandler.getLastName().empty()
  674. /*|| !gLoginHandler.getWebLoginKey().isNull()*/ )
  675. {
  676. // We have at least some login information on a SLURL
  677. gFirstname = gLoginHandler.getFirstName();
  678. gLastname = gLoginHandler.getLastName();
  679. LL_DEBUGS("LLStartup") << "STATE_FIRST: setting gFirstname, gLastname from gLoginHandler: '" << gFirstname << "' '" << gLastname << "'" << LL_ENDL;
  681. // Show the login screen if we don't have everything
  682. show_connect_box = 
  683. gFirstname.empty() || gLastname.empty();
  684. }
  685.         else if(gSavedSettings.getLLSD("UserLoginInfo").size() == 3)
  686.         {
  687.             LLSD cmd_line_login = gSavedSettings.getLLSD("UserLoginInfo");
  688. gFirstname = cmd_line_login[0].asString();
  689. gLastname = cmd_line_login[1].asString();
  690. LL_DEBUGS("LLStartup") << "Setting gFirstname, gLastname from gSavedSettings("UserLoginInfo"): '" << gFirstname << "' '" << gLastname << "'" << LL_ENDL;
  692. LLMD5 pass((unsigned char*)cmd_line_login[2].asString().c_str());
  693. char md5pass[33];               /* Flawfinder: ignore */
  694. pass.hex_digest(md5pass);
  695. gPassword = md5pass;
  697. #ifdef USE_VIEWER_AUTH
  698. show_connect_box = true;
  699. #else
  700. show_connect_box = false;
  701. #endif
  702. gSavedSettings.setBOOL("AutoLogin", TRUE);
  703.         }
  704. else if (gSavedSettings.getBOOL("AutoLogin"))
  705. {
  706. gFirstname = gSavedSettings.getString("FirstName");
  707. gLastname = gSavedSettings.getString("LastName");
  708. LL_DEBUGS("LLStartup") << "AutoLogin: setting gFirstname, gLastname from gSavedSettings("First|LastName"): '" << gFirstname << "' '" << gLastname << "'" << LL_ENDL;
  709. gPassword = LLStartUp::loadPasswordFromDisk();
  710. gSavedSettings.setBOOL("RememberPassword", TRUE);
  712. #ifdef USE_VIEWER_AUTH
  713. show_connect_box = true;
  714. #else
  715. show_connect_box = false;
  716. #endif
  717. }
  718. else
  719. {
  720. // if not automatically logging in, display login dialog
  721. // a valid grid is selected
  722. gFirstname = gSavedSettings.getString("FirstName");
  723. gLastname = gSavedSettings.getString("LastName");
  724. LL_DEBUGS("LLStartup") << "normal login: setting gFirstname, gLastname from gSavedSettings("First|LastName"): '" << gFirstname << "' '" << gLastname << "'" << LL_ENDL;
  725. gPassword = LLStartUp::loadPasswordFromDisk();
  726. show_connect_box = true;
  727. }
  730. // Go to the next startup state
  731. LLStartUp::setStartupState( STATE_BROWSER_INIT );
  732. return FALSE;
  733. }
  736. if (STATE_BROWSER_INIT == LLStartUp::getStartupState())
  737. {
  738. LL_DEBUGS("AppInit") << "STATE_BROWSER_INIT" << LL_ENDL;
  739. std::string msg = LLTrans::getString("LoginInitializingBrowser");
  740. set_startup_status(0.03f, msg.c_str(), gAgent.mMOTD.c_str());
  741. display_startup();
  742. // LLViewerMedia::initBrowser();
  743. LLStartUp::setStartupState( STATE_LOGIN_SHOW );
  744. return FALSE;
  745. }
  748. if (STATE_LOGIN_SHOW == LLStartUp::getStartupState())
  749. {
  750. LL_DEBUGS("AppInit") << "Initializing Window" << LL_ENDL;
  752. gViewerWindow->getWindow()->setCursor(UI_CURSOR_ARROW);
  754. timeout_count = 0;
  756. if (show_connect_box)
  757. {
  758. // Load all the name information out of the login view
  759. // NOTE: Hits "Attempted getFields with no login view shown" warning, since we don't
  760. // show the login view until login_show() is called below.  
  761. // LLPanelLogin::getFields(gFirstname, gLastname, gPassword);
  763. if (gNoRender)
  764. {
  765. LL_ERRS("AppInit") << "Need to autologin or use command line with norender!" << LL_ENDL;
  766. }
  767. // Make sure the process dialog doesn't hide things
  768. gViewerWindow->setShowProgress(FALSE);
  770. // Show the login dialog
  771. login_show();
  772. // connect dialog is already shown, so fill in the names
  773. LLPanelLogin::setFields( gFirstname, gLastname, gPassword);
  775. LLPanelLogin::giveFocus();
  777. gSavedSettings.setBOOL("FirstRunThisInstall", FALSE);
  779. LLStartUp::setStartupState( STATE_LOGIN_WAIT ); // Wait for user input
  780. }
  781. else
  782. {
  783. // skip directly to message template verification
  784. LLStartUp::setStartupState( STATE_LOGIN_CLEANUP );
  785. }
  787. // *NOTE: This is where LLViewerParcelMgr::getInstance() used to get allocated before becoming LLViewerParcelMgr::getInstance().
  789. // *NOTE: This is where gHUDManager used to bet allocated before becoming LLHUDManager::getInstance().
  791. // *NOTE: This is where gMuteList used to get allocated before becoming LLMuteList::getInstance().
  793. // Login screen needs menus for preferences, but we can enter
  794. // this startup phase more than once.
  795. if (gLoginMenuBarView == NULL)
  796. {
  797. init_menus();
  798. }
  800. gViewerWindow->setNormalControlsVisible( FALSE );
  801. gLoginMenuBarView->setVisible( TRUE );
  802. gLoginMenuBarView->setEnabled( TRUE );
  804. // Hide the splash screen
  805. LLSplashScreen::hide();
  807. // Push our window frontmost
  808. gViewerWindow->getWindow()->show();
  809. display_startup();
  811. //DEV-10530.  do cleanup.  remove at some later date.  jan-2009
  812. LLFloaterPreference::cleanupBadSetting();
  814. // DEV-16927.  The following code removes errant keystrokes that happen while the window is being 
  815. // first made visible.
  816. #ifdef _WIN32
  817. MSG msg;
  818. while( PeekMessage( &msg, /*All hWnds owned by this thread */ NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE ) );
  819. #endif
  820. timeout.reset();
  821. return FALSE;
  822. }
  824. if (STATE_LOGIN_WAIT == LLStartUp::getStartupState())
  825. {
  826. // Don't do anything.  Wait for the login view to call the login_callback,
  827. // which will push us to the next state.
  829. // Sleep so we don't spin the CPU
  830. ms_sleep(1);
  831. return FALSE;
  832. }
  834. if (STATE_LOGIN_CLEANUP == LLStartUp::getStartupState())
  835. {
  836. // Move the progress view in front of the UI immediately when login is performed
  837. // this allows not to see main menu after Alt+Tab was pressed while login. EXT-744.
  838. gViewerWindow->moveProgressViewToFront();
  840. //reset the values that could have come in from a slurl
  841. // DEV-42215: Make sure they're not empty -- gFirstname and gLastname
  842. // might already have been set from gSavedSettings, and it's too bad
  843. // to overwrite valid values with empty strings.
  844. if (! gLoginHandler.getFirstName().empty() && ! gLoginHandler.getLastName().empty())
  845. {
  846. gFirstname = gLoginHandler.getFirstName();
  847. gLastname = gLoginHandler.getLastName();
  848. LL_DEBUGS("LLStartup") << "STATE_LOGIN_CLEANUP: setting gFirstname, gLastname from gLoginHandler: '" << gFirstname << "' '" << gLastname << "'" << LL_ENDL;
  849. }
  851. if (show_connect_box)
  852. {
  853. // TODO if not use viewer auth
  854. // Load all the name information out of the login view
  855. LLPanelLogin::getFields(&gFirstname, &gLastname, &gPassword);
  856. // end TODO
  857.  
  858. // HACK: Try to make not jump on login
  859. gKeyboard->resetKeys();
  860. }
  862. if (!gFirstname.empty() && !gLastname.empty())
  863. {
  864. gSavedSettings.setString("FirstName", gFirstname);
  865. gSavedSettings.setString("LastName", gLastname);
  867. LL_INFOS("AppInit") << "Attempting login as: " << gFirstname << " " << gLastname << LL_ENDL;
  868. gDebugInfo["LoginName"] = gFirstname + " " + gLastname;
  869. }
  871. // create necessary directories
  872. // *FIX: these mkdir's should error check
  873. gDirUtilp->setLindenUserDir(gFirstname, gLastname);
  874. LLFile::mkdir(gDirUtilp->getLindenUserDir());
  876. // Set PerAccountSettingsFile to the default value.
  877. gSavedSettings.setString("PerAccountSettingsFile",
  878. gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, 
  879. LLAppViewer::instance()->getSettingsFilename("Default", "PerAccount")));
  881. // Note: can't store warnings files per account because some come up before login
  883. // Overwrite default user settings with user settings  
  884. LLAppViewer::instance()->loadSettingsFromDirectory("Account");
  886. // Need to set the LastLogoff time here if we don't have one.  LastLogoff is used for "Recent Items" calculation
  887. // and startup time is close enough if we don't have a real value.
  888. if (gSavedPerAccountSettings.getU32("LastLogoff") == 0)
  889. {
  890. gSavedPerAccountSettings.setU32("LastLogoff", time_corrected());
  891. }
  893. //Default the path if one isn't set.
  894. if (gSavedPerAccountSettings.getString("InstantMessageLogFolder").empty())
  895. {
  896. gDirUtilp->setChatLogsDir(gDirUtilp->getOSUserAppDir());
  897. std::string chat_log_dir = gDirUtilp->getChatLogsDir();
  898. std::string chat_log_top_folder=gDirUtilp->getBaseFileName(chat_log_dir);
  899. gSavedPerAccountSettings.setString("InstantMessageLogPath",chat_log_dir);
  900. gSavedPerAccountSettings.setString("InstantMessageLogFolder",chat_log_top_folder);
  901. }
  902. else
  903. {
  904. gDirUtilp->setChatLogsDir(gSavedPerAccountSettings.getString("InstantMessageLogPath"));
  905. }
  907. gDirUtilp->setPerAccountChatLogsDir(gFirstname, gLastname);
  909. LLFile::mkdir(gDirUtilp->getChatLogsDir());
  910. LLFile::mkdir(gDirUtilp->getPerAccountChatLogsDir());
  913. //good a place as any to create user windlight directories
  914. std::string user_windlight_path_name(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight", ""));
  915. LLFile::mkdir(user_windlight_path_name.c_str());
  917. std::string user_windlight_skies_path_name(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/skies", ""));
  918. LLFile::mkdir(user_windlight_skies_path_name.c_str());
  920. std::string user_windlight_water_path_name(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/water", ""));
  921. LLFile::mkdir(user_windlight_water_path_name.c_str());
  923. std::string user_windlight_days_path_name(gDirUtilp->getExpandedFilename( LL_PATH_USER_SETTINGS , "windlight/days", ""));
  924. LLFile::mkdir(user_windlight_days_path_name.c_str());
  927. if (show_connect_box)
  928. {
  929. std::string location;
  930. LLPanelLogin::getLocation( location );
  931. LLURLSimString::setString( location );
  933. // END TODO
  934. LLPanelLogin::closePanel();
  935. }
  938. // Load URL History File
  939. LLURLHistory::loadFile("url_history.xml");
  940. // Load location history 
  941. LLLocationHistory::getInstance()->load();
  943. // Load Avatars icons cache
  944. LLAvatarIconIDCache::getInstance()->load();
  946. //-------------------------------------------------
  947. // Handle startup progress screen
  948. //-------------------------------------------------
  950. // on startup the user can request to go to their home,
  951. // their last location, or some URL "-url //sim/x/y[/z]"
  952. // All accounts have both a home and a last location, and we don't support
  953. // more locations than that.  Choose the appropriate one.  JC
  954. if (LLURLSimString::parse())
  955. {
  956. // a startup URL was specified
  957. agent_location_id = START_LOCATION_ID_URL;
  959. // doesn't really matter what location_which is, since
  960. // gAgentStartLookAt will be overwritten when the
  961. // UserLoginLocationReply arrives
  962. location_which = START_LOCATION_ID_LAST;
  963. }
  964. else if (gSavedSettings.getString("LoginLocation") == "last" )
  965. {
  966. agent_location_id = START_LOCATION_ID_LAST; // last location
  967. location_which = START_LOCATION_ID_LAST;
  968. }
  969. else
  970. {
  971. agent_location_id = START_LOCATION_ID_HOME; // home
  972. location_which = START_LOCATION_ID_HOME;
  973. }
  975. gViewerWindow->getWindow()->setCursor(UI_CURSOR_WAIT);
  977. if (!gNoRender)
  978. {
  979. init_start_screen(agent_location_id);
  980. }
  982. // Display the startup progress bar.
  983. gViewerWindow->setShowProgress(TRUE);
  984. gViewerWindow->setProgressCancelButtonVisible(TRUE, LLTrans::getString("Quit"));
  986. // Poke the VFS, which could potentially block for a while if
  987. // Windows XP is acting up
  988. set_startup_status(0.07f, LLTrans::getString("LoginVerifyingCache"), LLStringUtil::null);
  989. display_startup();
  991. gVFS->pokeFiles();
  993. LLStartUp::setStartupState( STATE_LOGIN_AUTH_INIT );
  995. return FALSE;
  996. }
  998. if(STATE_LOGIN_AUTH_INIT == LLStartUp::getStartupState())
  999. {
  1000. gDebugInfo["GridName"] = LLViewerLogin::getInstance()->getGridLabel();
  1002. // Update progress status and the display loop.
  1003. auth_desc = LLTrans::getString("LoginInProgress");
  1004. set_startup_status(progress, auth_desc, auth_message);
  1005. progress += 0.02f;
  1006. display_startup();
  1008. // Setting initial values...
  1009. LLLoginInstance* login = LLLoginInstance::getInstance();
  1010. login->setNotificationsInterface(LLNotifications::getInstance());
  1011. if(gNoRender)
  1012. {
  1013. // HACK, skip optional updates if you're running drones
  1014. login->setSkipOptionalUpdate(true);
  1015. }
  1017. login->setUserInteraction(show_connect_box);
  1018. login->setSerialNumber(LLAppViewer::instance()->getSerialNumber());
  1019. login->setLastExecEvent(gLastExecEvent);
  1020. login->setUpdaterLauncher(boost::bind(&LLAppViewer::launchUpdater, LLAppViewer::instance()));
  1022. // This call to LLLoginInstance::connect() starts the 
  1023. // authentication process.
  1024. LLSD credentials;
  1025. credentials["first"] = gFirstname;
  1026. credentials["last"] = gLastname;
  1027. credentials["passwd"] = gPassword;
  1028. login->connect(credentials);
  1030. LLStartUp::setStartupState( STATE_LOGIN_CURL_UNSTUCK );
  1031. return FALSE;
  1032. }
  1034. if(STATE_LOGIN_CURL_UNSTUCK == LLStartUp::getStartupState())
  1035. {
  1036. // If we get here we have gotten past the potential stall
  1037. // in curl, so take "may appear frozen" out of progress bar. JC
  1038. auth_desc = LLTrans::getString("LoginInProgressNoFrozen");
  1039. set_startup_status(progress, auth_desc, auth_message);
  1041. LLStartUp::setStartupState( STATE_LOGIN_PROCESS_RESPONSE );
  1042. return FALSE;
  1043. }
  1045. if(STATE_LOGIN_PROCESS_RESPONSE == LLStartUp::getStartupState()) 
  1046. {
  1047. std::ostringstream emsg;
  1048. emsg << "Login failed.n";
  1049. if(LLLoginInstance::getInstance()->authFailure())
  1050. {
  1051. LL_INFOS("LLStartup") << "Login failed, LLLoginInstance::getResponse(): "
  1052.                       << LLLoginInstance::getInstance()->getResponse() << LL_ENDL;
  1053. // Still have error conditions that may need some 
  1054. // sort of handling.
  1055. std::string reason_response = LLLoginInstance::getInstance()->getResponse("reason");
  1056. std::string message_response = LLLoginInstance::getInstance()->getResponse("message");
  1058. if(!message_response.empty())
  1059. {
  1060. // XUI: fix translation for strings returned during login
  1061. // We need a generic table for translations
  1062. std::string big_reason = LLAgent::sTeleportErrorMessages[ message_response ];
  1063. if ( big_reason.size() == 0 )
  1064. {
  1065. emsg << message_response;
  1066. }
  1067. else
  1068. {
  1069. emsg << big_reason;
  1070. }
  1071. }
  1073. if(reason_response == "key")
  1074. {
  1075. // Couldn't login because user/password is wrong
  1076. // Clear the password
  1077. gPassword = "";
  1078. }
  1080. if(reason_response == "update" 
  1081. || reason_response == "optional")
  1082. {
  1083. // In the case of a needed update, quit.
  1084. // Its either downloading or declined.
  1085. // If optional was skipped this case shouldn't 
  1086. // be reached.
  1087. LLLoginInstance::getInstance()->disconnect();
  1088. LLAppViewer::instance()->forceQuit();
  1089. }
  1090. else
  1091. {
  1092. // Don't pop up a notification in the TOS case because
  1093. // LLFloaterTOS::onCancel() already scolded the user.
  1094. if (reason_response != "tos")
  1095. {
  1096. LLSD args;
  1097. args["ERROR_MESSAGE"] = emsg.str();
  1098. LL_INFOS("LLStartup") << "Notification: " << args << LL_ENDL;
  1099. LLNotificationsUtil::add("ErrorMessage", args, LLSD(), login_alert_done);
  1100. }
  1102. //setup map of datetime strings to codes and slt & local time offset from utc
  1103. // *TODO: Does this need to be here?
  1104. LLStringOps::setupDatetimeInfo (false);
  1105. transition_back_to_login_panel(emsg.str());
  1106. show_connect_box = true;
  1107. }
  1108. }
  1109. else if(LLLoginInstance::getInstance()->authSuccess())
  1110. {
  1111. if(process_login_success_response())
  1112. {
  1113. // Pass the user information to the voice chat server interface.
  1114. gVoiceClient->userAuthorized(gFirstname, gLastname, gAgentID);
  1115. LLStartUp::setStartupState( STATE_WORLD_INIT);
  1116. }
  1117. else
  1118. {
  1119. LLSD args;
  1120. args["ERROR_MESSAGE"] = emsg.str();
  1121. LL_INFOS("LLStartup") << "Notification: " << args << LL_ENDL;
  1122. LLNotificationsUtil::add("ErrorMessage", args, LLSD(), login_alert_done);
  1123. transition_back_to_login_panel(emsg.str());
  1124. show_connect_box = true;
  1125. }
  1126. }
  1127. return FALSE;
  1128. }
  1130. //---------------------------------------------------------------------
  1131. // World Init
  1132. //---------------------------------------------------------------------
  1133. if (STATE_WORLD_INIT == LLStartUp::getStartupState())
  1134. {
  1135. set_startup_status(0.30f, LLTrans::getString("LoginInitializingWorld"), gAgent.mMOTD);
  1136. display_startup();
  1137. // We should have an agent id by this point.
  1138. llassert(!(gAgentID == LLUUID::null));
  1140. // Finish agent initialization.  (Requires gSavedSettings, builds camera)
  1141. gAgent.init();
  1142. set_underclothes_menu_options();
  1144. // Since we connected, save off the settings so the user doesn't have to
  1145. // type the name/password again if we crash.
  1146. gSavedSettings.saveToFile(gSavedSettings.getString("ClientSettingsFile"), TRUE);
  1147. LLUIColorTable::instance().saveUserSettings();
  1149. //
  1150. // Initialize classes w/graphics stuff.
  1151. //
  1152. gTextureList.doPrefetchImages();
  1153. LLSurface::initClasses();
  1155. LLFace::initClass();
  1157. LLDrawable::initClass();
  1159. // init the shader managers
  1160. LLPostProcess::initClass();
  1161. LLWLParamManager::initClass();
  1162. LLWaterParamManager::initClass();
  1164. LLViewerObject::initVOClasses();
  1166. // Initialize all our tools.  Must be done after saved settings loaded.
  1167. // NOTE: This also is where gToolMgr used to be instantiated before being turned into a singleton.
  1168. LLToolMgr::getInstance()->initTools();
  1170. // Pre-load floaters, like the world map, that are slow to spawn
  1171. // due to XML complexity.
  1172. gViewerWindow->initWorldUI();
  1174. display_startup();
  1176. // This is where we used to initialize gWorldp. Original comment said:
  1177. // World initialization must be done after above window init
  1179. // User might have overridden far clip
  1180. LLWorld::getInstance()->setLandFarClip( gAgent.mDrawDistance );
  1182. // Before we create the first region, we need to set the agent's mOriginGlobal
  1183. // This is necessary because creating objects before this is set will result in a
  1184. // bad mPositionAgent cache.
  1186. gAgent.initOriginGlobal(from_region_handle(gFirstSimHandle));
  1188. LLWorld::getInstance()->addRegion(gFirstSimHandle, gFirstSim);
  1190. LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromHandle(gFirstSimHandle);
  1191. LL_INFOS("AppInit") << "Adding initial simulator " << regionp->getOriginGlobal() << LL_ENDL;
  1193. regionp->setSeedCapability(gFirstSimSeedCap);
  1194. LL_DEBUGS("AppInit") << "Waiting for seed grant ...." << LL_ENDL;
  1196. // Set agent's initial region to be the one we just created.
  1197. gAgent.setRegion(regionp);
  1199. // Set agent's initial position, which will be read by LLVOAvatar when the avatar
  1200. // object is created.  I think this must be done after setting the region.  JC
  1201. gAgent.setPositionAgent(agent_start_position_region);
  1203. display_startup();
  1204. LLStartUp::setStartupState( STATE_MULTIMEDIA_INIT );
  1206. return FALSE;
  1207. }
  1210. //---------------------------------------------------------------------
  1211. // Load QuickTime/GStreamer and other multimedia engines, can be slow.
  1212. // Do it while we're waiting on the network for our seed capability. JC
  1213. //---------------------------------------------------------------------
  1214. if (STATE_MULTIMEDIA_INIT == LLStartUp::getStartupState())
  1215. {
  1216. LLStartUp::multimediaInit();
  1217. LLStartUp::setStartupState( STATE_FONT_INIT );
  1218. return FALSE;
  1219. }
  1221. // Loading fonts takes several seconds
  1222. if (STATE_FONT_INIT == LLStartUp::getStartupState())
  1223. {
  1224. LLStartUp::fontInit();
  1225. LLStartUp::setStartupState( STATE_SEED_GRANTED_WAIT );
  1226. return FALSE;
  1227. }
  1229. //---------------------------------------------------------------------
  1230. // Wait for Seed Cap Grant
  1231. //---------------------------------------------------------------------
  1232. if(STATE_SEED_GRANTED_WAIT == LLStartUp::getStartupState())
  1233. {
  1234. return FALSE;
  1235. }
  1238. //---------------------------------------------------------------------
  1239. // Seed Capability Granted
  1240. // no newMessage calls should happen before this point
  1241. //---------------------------------------------------------------------
  1242. if (STATE_SEED_CAP_GRANTED == LLStartUp::getStartupState())
  1243. {
  1244. update_texture_fetch();
  1246. if ( gViewerWindow != NULL)
  1247. { // This isn't the first logon attempt, so show the UI
  1248. gViewerWindow->setNormalControlsVisible( TRUE );
  1249. }
  1250. gLoginMenuBarView->setVisible( FALSE );
  1251. gLoginMenuBarView->setEnabled( FALSE );
  1253. if (!gNoRender)
  1254. {
  1255. // Move the progress view in front of the UI
  1256. gViewerWindow->moveProgressViewToFront();
  1258. // direct logging to the debug console's line buffer
  1259. LLError::logToFixedBuffer(gDebugView->mDebugConsolep);
  1261. // set initial visibility of debug console
  1262. gDebugView->mDebugConsolep->setVisible(gSavedSettings.getBOOL("ShowDebugConsole"));
  1263. }
  1265. //
  1266. // Set message handlers
  1267. //
  1268. LL_INFOS("AppInit") << "Initializing communications..." << LL_ENDL;
  1270. // register callbacks for messages. . . do this after initial handshake to make sure that we don't catch any unwanted
  1271. register_viewer_callbacks(gMessageSystem);
  1273. // Debugging info parameters
  1274. gMessageSystem->setMaxMessageTime( 0.5f ); // Spam if decoding all msgs takes more than 500 ms
  1276. #ifndef LL_RELEASE_FOR_DOWNLOAD
  1277. gMessageSystem->setTimeDecodes( TRUE ); // Time the decode of each msg
  1278. gMessageSystem->setTimeDecodesSpamThreshold( 0.05f );  // Spam if a single msg takes over 50ms to decode
  1279. #endif
  1281. gXferManager->registerCallbacks(gMessageSystem);
  1283. if ( gCacheName == NULL )
  1284. {
  1285. gCacheName = new LLCacheName(gMessageSystem);
  1286. gCacheName->addObserver(&callback_cache_name);
  1287. gCacheName->LocalizeCacheName("waiting", LLTrans::getString("AvatarNameWaiting"));
  1288. gCacheName->LocalizeCacheName("nobody", LLTrans::getString("AvatarNameNobody"));
  1289. gCacheName->LocalizeCacheName("none", LLTrans::getString("GroupNameNone"));
  1290. // Load stored cache if possible
  1291.             LLAppViewer::instance()->loadNameCache();
  1292. }
  1294. //gCacheName is required for nearby chat history loading
  1295. //so I just moved nearby history loading a few states further
  1296. if (!gNoRender && gSavedPerAccountSettings.getBOOL("LogShowHistory"))
  1297. {
  1298. LLNearbyChat* nearby_chat = LLNearbyChat::getInstance();
  1299. if (nearby_chat) nearby_chat->loadHistory();
  1300. }
  1302. // *Note: this is where gWorldMap used to be initialized.
  1304. // register null callbacks for audio until the audio system is initialized
  1305. gMessageSystem->setHandlerFuncFast(_PREHASH_SoundTrigger, null_message_callback, NULL);
  1306. gMessageSystem->setHandlerFuncFast(_PREHASH_AttachedSound, null_message_callback, NULL);
  1308. //reset statistics
  1309. LLViewerStats::getInstance()->resetStats();
  1311. display_startup();
  1312. //
  1313. // Set up region and surface defaults
  1314. //
  1317. // Sets up the parameters for the first simulator
  1319. LL_DEBUGS("AppInit") << "Initializing camera..." << LL_ENDL;
  1320. gFrameTime    = totalTime();
  1321. F32 last_time = gFrameTimeSeconds;
  1322. gFrameTimeSeconds = (S64)(gFrameTime - gStartTime)/SEC_TO_MICROSEC;
  1324. gFrameIntervalSeconds = gFrameTimeSeconds - last_time;
  1325. if (gFrameIntervalSeconds < 0.f)
  1326. {
  1327. gFrameIntervalSeconds = 0.f;
  1328. }
  1330. // Make sure agent knows correct aspect ratio
  1331. // FOV limits depend upon aspect ratio so this needs to happen before initializing the FOV below
  1332. LLViewerCamera::getInstance()->setViewHeightInPixels(gViewerWindow->getWorldViewHeightRaw());
  1333. LLViewerCamera::getInstance()->setAspect(gViewerWindow->getWorldViewAspectRatio());
  1334. // Initialize FOV
  1335. LLViewerCamera::getInstance()->setDefaultFOV(gSavedSettings.getF32("CameraAngle")); 
  1337. // Move agent to starting location. The position handed to us by
  1338. // the space server is in global coordinates, but the agent frame
  1339. // is in region local coordinates. Therefore, we need to adjust
  1340. // the coordinates handed to us to fit in the local region.
  1342. gAgent.setPositionAgent(agent_start_position_region);
  1343. gAgent.resetAxes(gAgentStartLookAt);
  1344. gAgent.stopCameraAnimation();
  1345. gAgent.resetCamera();
  1347. // Initialize global class data needed for surfaces (i.e. textures)
  1348. if (!gNoRender)
  1349. {
  1350. LL_DEBUGS("AppInit") << "Initializing sky..." << LL_ENDL;
  1351. // Initialize all of the viewer object classes for the first time (doing things like texture fetches.
  1352. LLGLState::checkStates();
  1353. LLGLState::checkTextureChannels();
  1355. gSky.init(initial_sun_direction);
  1357. LLGLState::checkStates();
  1358. LLGLState::checkTextureChannels();
  1359. }
  1361. LL_DEBUGS("AppInit") << "Decoding images..." << LL_ENDL;
  1362. // For all images pre-loaded into viewer cache, decode them.
  1363. // Need to do this AFTER we init the sky
  1364. const S32 DECODE_TIME_SEC = 2;
  1365. for (int i = 0; i < DECODE_TIME_SEC; i++)
  1366. {
  1367. F32 frac = (F32)i / (F32)DECODE_TIME_SEC;
  1368. set_startup_status(0.45f + frac*0.1f, LLTrans::getString("LoginDecodingImages"), gAgent.mMOTD);
  1369. display_startup();
  1370. gTextureList.decodeAllImages(1.f);
  1371. }
  1372. LLStartUp::setStartupState( STATE_WORLD_WAIT );
  1374. // JC - Do this as late as possible to increase likelihood Purify
  1375. // will run.
  1376. LLMessageSystem* msg = gMessageSystem;
  1377. if (!msg->mOurCircuitCode)
  1378. {
  1379. LL_WARNS("AppInit") << "Attempting to connect to simulator with a zero circuit code!" << LL_ENDL;
  1380. }
  1382. gUseCircuitCallbackCalled = false;
  1384. msg->enableCircuit(gFirstSim, TRUE);
  1385. // now, use the circuit info to tell simulator about us!
  1386. LL_INFOS("AppInit") << "viewer: UserLoginLocationReply() Enabling " << gFirstSim << " with code " << msg->mOurCircuitCode << LL_ENDL;
  1387. msg->newMessageFast(_PREHASH_UseCircuitCode);
  1388. msg->nextBlockFast(_PREHASH_CircuitCode);
  1389. msg->addU32Fast(_PREHASH_Code, msg->mOurCircuitCode);
  1390. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1391. msg->addUUIDFast(_PREHASH_ID, gAgent.getID());
  1392. msg->sendReliable(
  1393. gFirstSim,
  1394. gSavedSettings.getS32("UseCircuitCodeMaxRetries"),
  1395. FALSE,
  1396. gSavedSettings.getF32("UseCircuitCodeTimeout"),
  1397. use_circuit_callback,
  1398. NULL);
  1400. timeout.reset();
  1402. return FALSE;
  1403. }
  1405. //---------------------------------------------------------------------
  1406. // Agent Send
  1407. //---------------------------------------------------------------------
  1408. if(STATE_WORLD_WAIT == LLStartUp::getStartupState())
  1409. {
  1410. LL_DEBUGS("AppInit") << "Waiting for simulator ack...." << LL_ENDL;
  1411. set_startup_status(0.59f, LLTrans::getString("LoginWaitingForRegionHandshake"), gAgent.mMOTD);
  1412. if(gGotUseCircuitCodeAck)
  1413. {
  1414. LLStartUp::setStartupState( STATE_AGENT_SEND );
  1415. }
  1416. LLMessageSystem* msg = gMessageSystem;
  1417. while (msg->checkAllMessages(gFrameCount, gServicePump))
  1418. {
  1419. }
  1420. msg->processAcks();
  1421. return FALSE;
  1422. }
  1424. //---------------------------------------------------------------------
  1425. // Agent Send
  1426. //---------------------------------------------------------------------
  1427. if (STATE_AGENT_SEND == LLStartUp::getStartupState())
  1428. {
  1429. LL_DEBUGS("AppInit") << "Connecting to region..." << LL_ENDL;
  1430. set_startup_status(0.60f, LLTrans::getString("LoginConnectingToRegion"), gAgent.mMOTD);
  1431. // register with the message system so it knows we're
  1432. // expecting this message
  1433. LLMessageSystem* msg = gMessageSystem;
  1434. msg->setHandlerFuncFast(
  1435. _PREHASH_AgentMovementComplete,
  1436. process_agent_movement_complete);
  1437. LLViewerRegion* regionp = gAgent.getRegion();
  1438. if(regionp)
  1439. {
  1440. send_complete_agent_movement(regionp->getHost());
  1441. gAssetStorage->setUpstream(regionp->getHost());
  1442. gCacheName->setUpstream(regionp->getHost());
  1443. msg->newMessageFast(_PREHASH_EconomyDataRequest);
  1444. gAgent.sendReliableMessage();
  1445. }
  1447. // Create login effect
  1448. // But not on first login, because you can't see your avatar then
  1449. if (!gAgent.isFirstLogin())
  1450. {
  1451. LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINT, TRUE);
  1452. effectp->setPositionGlobal(gAgent.getPositionGlobal());
  1453. effectp->setColor(LLColor4U(gAgent.getEffectColor()));
  1454. LLHUDManager::getInstance()->sendEffects();
  1455. }
  1457. LLStartUp::setStartupState( STATE_AGENT_WAIT ); // Go to STATE_AGENT_WAIT
  1459. timeout.reset();
  1460. return FALSE;
  1461. }
  1463. //---------------------------------------------------------------------
  1464. // Agent Wait
  1465. //---------------------------------------------------------------------
  1466. if (STATE_AGENT_WAIT == LLStartUp::getStartupState())
  1467. {
  1468. LLMessageSystem* msg = gMessageSystem;
  1469. while (msg->checkAllMessages(gFrameCount, gServicePump))
  1470. {
  1471. if (gAgentMovementCompleted)
  1472. {
  1473. // Sometimes we have more than one message in the
  1474. // queue. break out of this loop and continue
  1475. // processing. If we don't, then this could skip one
  1476. // or more login steps.
  1477. break;
  1478. }
  1479. else
  1480. {
  1481. LL_DEBUGS("AppInit") << "Awaiting AvatarInitComplete, got "
  1482. << msg->getMessageName() << LL_ENDL;
  1483. }
  1484. }
  1485. msg->processAcks();
  1487. if (gAgentMovementCompleted)
  1488. {
  1489. LLStartUp::setStartupState( STATE_INVENTORY_SEND );
  1490. }
  1492. return FALSE;
  1493. }
  1495. //---------------------------------------------------------------------
  1496. // Inventory Send
  1497. //---------------------------------------------------------------------
  1498. if (STATE_INVENTORY_SEND == LLStartUp::getStartupState())
  1499. {
  1500. // Inform simulator of our language preference
  1501. LLAgentLanguage::update();
  1503. // unpack thin inventory
  1504. LLSD response = LLLoginInstance::getInstance()->getResponse();
  1505. //bool dump_buffer = false;
  1507. LLSD inv_lib_root = response["inventory-lib-root"];
  1508. if(inv_lib_root.isDefined())
  1509. {
  1510. // should only be one
  1511. LLSD id = inv_lib_root[0]["folder_id"];
  1512. if(id.isDefined())
  1513. {
  1514. gInventory.setLibraryRootFolderID(id.asUUID());
  1515. }
  1516. }
  1517.  
  1518. LLSD inv_lib_owner = response["inventory-lib-owner"];
  1519. if(inv_lib_owner.isDefined())
  1520. {
  1521. // should only be one
  1522. LLSD id = inv_lib_owner[0]["agent_id"];
  1523. if(id.isDefined())
  1524. {
  1525. gInventory.setLibraryOwnerID( LLUUID(id.asUUID()));
  1526. }
  1527. }
  1529. LLSD inv_skel_lib = response["inventory-skel-lib"];
  1530.   if(inv_skel_lib.isDefined() && gInventory.getLibraryOwnerID().notNull())
  1531.   {
  1532.   if(!gInventory.loadSkeleton(inv_skel_lib, gInventory.getLibraryOwnerID()))
  1533.   {
  1534.   LL_WARNS("AppInit") << "Problem loading inventory-skel-lib" << LL_ENDL;
  1535.   }
  1536.   }
  1538. LLSD inv_skeleton = response["inventory-skeleton"];
  1539.   if(inv_skeleton.isDefined())
  1540.   {
  1541.   if(!gInventory.loadSkeleton(inv_skeleton, gAgent.getID()))
  1542.   {
  1543.   LL_WARNS("AppInit") << "Problem loading inventory-skel-targets" << LL_ENDL;
  1544.   }
  1545.   }
  1547. LLSD buddy_list = response["buddy-list"];
  1548.   if(buddy_list.isDefined())
  1549.   {
  1550. LLAvatarTracker::buddy_map_t list;
  1551. LLUUID agent_id;
  1552. S32 has_rights = 0, given_rights = 0;
  1553. for(LLSD::array_const_iterator it = buddy_list.beginArray(),
  1554. end = buddy_list.endArray(); it != end; ++it)
  1555. {
  1556. LLSD buddy_id = (*it)["buddy_id"];
  1557. if(buddy_id.isDefined())
  1558. {
  1559. agent_id = buddy_id.asUUID();
  1560. }
  1562. LLSD buddy_rights_has = (*it)["buddy_rights_has"];
  1563. if(buddy_rights_has.isDefined())
  1564. {
  1565. has_rights = buddy_rights_has.asInteger();
  1566. }
  1568. LLSD buddy_rights_given = (*it)["buddy_rights_given"];
  1569. if(buddy_rights_given.isDefined())
  1570. {
  1571. given_rights = buddy_rights_given.asInteger();
  1572. }
  1574. list[agent_id] = new LLRelationship(given_rights, has_rights, false);
  1575. }
  1576. LLAvatarTracker::instance().addBuddyList(list);
  1577.   }
  1579. bool show_hud = false;
  1580. LLSD tutorial_setting = response["tutorial_setting"];
  1581. if(tutorial_setting.isDefined())
  1582. {
  1583. for(LLSD::array_const_iterator it = tutorial_setting.beginArray(),
  1584. end = tutorial_setting.endArray(); it != end; ++it)
  1585. {
  1586. LLSD tutorial_url = (*it)["tutorial_url"];
  1587. if(tutorial_url.isDefined())
  1588. {
  1589. // Tutorial floater will append language code
  1590. gSavedSettings.setString("TutorialURL", tutorial_url.asString());
  1591. }
  1593. // For Viewer 2.0 we are not using the web-based tutorial
  1594. // If we reverse that decision, put this code back and use
  1595. // login.cgi to send a different URL with content that matches
  1596. // the Viewer 2.0 UI.
  1597. //LLSD use_tutorial = (*it)["use_tutorial"];
  1598. //if(use_tutorial.asString() == "true")
  1599. //{
  1600. // show_hud = true;
  1601. //}
  1602. }
  1603. }
  1604. // Either we want to show tutorial because this is the first login
  1605. // to a Linden Help Island or the user quit with the tutorial
  1606. // visible.  JC
  1607. if (show_hud || gSavedSettings.getBOOL("ShowTutorial"))
  1608. {
  1609. LLFloaterReg::showInstance("hud", LLSD(), FALSE);
  1610. }
  1612. LLSD event_categories = response["event_categories"];
  1613. if(event_categories.isDefined())
  1614. {
  1615. LLEventInfo::loadCategories(event_categories);
  1616. }
  1618. LLSD event_notifications = response["event_notifications"];
  1619. if(event_notifications.isDefined())
  1620. {
  1621. gEventNotifier.load(event_notifications);
  1622. }
  1624. LLSD classified_categories = response["classified_categories"];
  1625. if(classified_categories.isDefined())
  1626. {
  1627. LLClassifiedInfo::loadCategories(classified_categories);
  1628. }
  1631. // This method MUST be called before gInventory.findCategoryUUIDForType because of 
  1632. // gInventory.mIsAgentInvUsable is set to true in the gInventory.buildParentChildMap.
  1633. gInventory.buildParentChildMap();
  1635. //all categories loaded. lets create "My Favorites" category
  1636. gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE,true);
  1638. // Checks whether "Friends" and "Friends/All" folders exist in "Calling Cards" folder,
  1639. // fetches their contents if needed and synchronizes it with buddies list.
  1640. // If the folders are not found they are created.
  1641. LLFriendCardsManager::instance().syncFriendCardsFolders();
  1644. // set up callbacks
  1645. llinfos << "Registering Callbacks" << llendl;
  1646. LLMessageSystem* msg = gMessageSystem;
  1647. llinfos << " Inventory" << llendl;
  1648. LLInventoryModel::registerCallbacks(msg);
  1649. llinfos << " AvatarTracker" << llendl;
  1650. LLAvatarTracker::instance().registerCallbacks(msg);
  1651. llinfos << " Landmark" << llendl;
  1652. LLLandmark::registerCallbacks(msg);
  1654. // request mute list
  1655. llinfos << "Requesting Mute List" << llendl;
  1656. LLMuteList::getInstance()->requestFromServer(gAgent.getID());
  1658. // Get L$ and ownership credit information
  1659. llinfos << "Requesting Money Balance" << llendl;
  1660. LLStatusBar::sendMoneyBalanceRequest();
  1662. // request all group information
  1663. llinfos << "Requesting Agent Data" << llendl;
  1664. gAgent.sendAgentDataUpdateRequest();
  1666. // Create the inventory views
  1667. llinfos << "Creating Inventory Views" << llendl;
  1668. LLFloaterReg::getInstance("inventory");
  1670. LLStartUp::setStartupState( STATE_MISC );
  1671. return FALSE;
  1672. }
  1675. //---------------------------------------------------------------------
  1676. // Misc
  1677. //---------------------------------------------------------------------
  1678. if (STATE_MISC == LLStartUp::getStartupState())
  1679. {
  1680. // We have a region, and just did a big inventory download.
  1681. // We can estimate the user's connection speed, and set their
  1682. // max bandwidth accordingly.  JC
  1683. if (gSavedSettings.getBOOL("FirstLoginThisInstall"))
  1684. {
  1685. // This is actually a pessimistic computation, because TCP may not have enough
  1686. // time to ramp up on the (small) default inventory file to truly measure max
  1687. // bandwidth. JC
  1688. F64 rate_bps = LLLoginInstance::getInstance()->getLastTransferRateBPS();
  1689. const F32 FAST_RATE_BPS = 600.f * 1024.f;
  1690. const F32 FASTER_RATE_BPS = 750.f * 1024.f;
  1691. F32 max_bandwidth = gViewerThrottle.getMaxBandwidth();
  1692. if (rate_bps > FASTER_RATE_BPS
  1693. && rate_bps > max_bandwidth)
  1694. {
  1695. LL_DEBUGS("AppInit") << "Fast network connection, increasing max bandwidth to " 
  1696. << FASTER_RATE_BPS/1024.f 
  1697. << " kbps" << LL_ENDL;
  1698. gViewerThrottle.setMaxBandwidth(FASTER_RATE_BPS / 1024.f);
  1699. }
  1700. else if (rate_bps > FAST_RATE_BPS
  1701. && rate_bps > max_bandwidth)
  1702. {
  1703. LL_DEBUGS("AppInit") << "Fast network connection, increasing max bandwidth to " 
  1704. << FAST_RATE_BPS/1024.f 
  1705. << " kbps" << LL_ENDL;
  1706. gViewerThrottle.setMaxBandwidth(FAST_RATE_BPS / 1024.f);
  1707. }
  1709. // Set the show start location to true, now that the user has logged
  1710. // on with this install.
  1711. gSavedSettings.setBOOL("ShowStartLocation", TRUE);
  1713. LLSideTray::getInstance()->showPanel("panel_home", LLSD());
  1715. }
  1717. // We're successfully logged in.
  1718. gSavedSettings.setBOOL("FirstLoginThisInstall", FALSE);
  1720. LLFloaterReg::showInitialVisibleInstances();
  1722. // based on the comments, we've successfully logged in so we can delete the 'forced'
  1723. // URL that the updater set in settings.ini (in a mostly paranoid fashion)
  1724. std::string nextLoginLocation = gSavedSettings.getString( "NextLoginLocation" );
  1725. if ( nextLoginLocation.length() )
  1726. {
  1727. // clear it
  1728. gSavedSettings.setString( "NextLoginLocation", "" );
  1730. // and make sure it's saved
  1731. gSavedSettings.saveToFile( gSavedSettings.getString("ClientSettingsFile") , TRUE );
  1732. LLUIColorTable::instance().saveUserSettings();
  1733. };
  1735. if (!gNoRender)
  1736. {
  1737. // JC: Initializing audio requests many sounds for download.
  1738. init_audio();
  1740. // JC: Initialize "active" gestures.  This may also trigger
  1741. // many gesture downloads, if this is the user's first
  1742. // time on this machine or -purge has been run.
  1743. LLSD gesture_options 
  1744. = LLLoginInstance::getInstance()->getResponse("gestures");
  1745. if (gesture_options.isDefined())
  1746. {
  1747. LL_DEBUGS("AppInit") << "Gesture Manager loading " << gesture_options.size()
  1748. << LL_ENDL;
  1749. std::vector<LLUUID> item_ids;
  1750. for(LLSD::array_const_iterator resp_it = gesture_options.beginArray(),
  1751. end = gesture_options.endArray(); resp_it != end; ++resp_it)
  1752. {
  1753. // If the id is not specifed in the LLSD,
  1754. // the LLSD operator[]() will return a null LLUUID. 
  1755. LLUUID item_id = (*resp_it)["item_id"];
  1756. LLUUID asset_id = (*resp_it)["asset_id"];
  1758. if (item_id.notNull() && asset_id.notNull())
  1759. {
  1760. // Could schedule and delay these for later.
  1761. const BOOL no_inform_server = FALSE;
  1762. const BOOL no_deactivate_similar = FALSE;
  1763. LLGestureManager::instance().activateGestureWithAsset(item_id, asset_id,
  1764.  no_inform_server,
  1765.  no_deactivate_similar);
  1766. // We need to fetch the inventory items for these gestures
  1767. // so we have the names to populate the UI.
  1768. item_ids.push_back(item_id);
  1769. }
  1770. }
  1771. // no need to add gesture to inventory observer, it's already made in constructor 
  1772. LLGestureManager::instance().fetchItems(item_ids);
  1773. }
  1774. }
  1775. gDisplaySwapBuffers = TRUE;
  1777. LLMessageSystem* msg = gMessageSystem;
  1778. msg->setHandlerFuncFast(_PREHASH_SoundTrigger, process_sound_trigger);
  1779. msg->setHandlerFuncFast(_PREHASH_PreloadSound, process_preload_sound);
  1780. msg->setHandlerFuncFast(_PREHASH_AttachedSound, process_attached_sound);
  1781. msg->setHandlerFuncFast(_PREHASH_AttachedSoundGainChange, process_attached_sound_gain_change);
  1783. LL_DEBUGS("AppInit") << "Initialization complete" << LL_ENDL;
  1785. gRenderStartTime.reset();
  1786. gForegroundTime.reset();
  1788. // HACK: Inform simulator of window size.
  1789. // Do this here so it's less likely to race with RegisterNewAgent.
  1790. // TODO: Put this into RegisterNewAgent
  1791. // JC - 7/20/2002
  1792. gViewerWindow->sendShapeToSim();
  1795. // Ignore stipend information for now.  Money history is on the web site.
  1796. // if needed, show the L$ history window
  1797. //if (stipend_since_login && !gNoRender)
  1798. //{
  1799. //}
  1801. // The reason we show the alert is because we want to
  1802. // reduce confusion for when you log in and your provided
  1803. // location is not your expected location. So, if this is
  1804. // your first login, then you do not have an expectation,
  1805. // thus, do not show this alert.
  1806. if (!gAgent.isFirstLogin())
  1807. {
  1808. bool url_ok = LLURLSimString::sInstance.parse();
  1809. if ((url_ok && gAgentStartLocation == "url") ||
  1810. (!url_ok && ((gAgentStartLocation == gSavedSettings.getString("LoginLocation")))))
  1811. {
  1812. // Start location is OK
  1813. // Disabled code to restore camera location and focus if logging in to default location
  1814. static bool samename = false;
  1815. if (samename)
  1816. {
  1817. // restore old camera pos
  1818. gAgent.setFocusOnAvatar(FALSE, FALSE);
  1819. gAgent.setCameraPosAndFocusGlobal(gSavedSettings.getVector3d("CameraPosOnLogout"), gSavedSettings.getVector3d("FocusPosOnLogout"), LLUUID::null);
  1820. BOOL limit_hit = FALSE;
  1821. gAgent.calcCameraPositionTargetGlobal(&limit_hit);
  1822. if (limit_hit)
  1823. {
  1824. gAgent.setFocusOnAvatar(TRUE, FALSE);
  1825. }
  1826. gAgent.stopCameraAnimation();
  1827. }
  1828. }
  1829. else
  1830. {
  1831. std::string msg;
  1832. if (url_ok)
  1833. {
  1834. msg = "AvatarMovedDesired";
  1835. }
  1836. else if (gSavedSettings.getString("LoginLocation") == "home")
  1837. {
  1838. msg = "AvatarMovedHome";
  1839. }
  1840. else
  1841. {
  1842. msg = "AvatarMovedLast";
  1843. }
  1844. LLNotificationsUtil::add(msg);
  1845. }
  1846. }
  1848.         //DEV-17797.  get null folder.  Any items found here moved to Lost and Found
  1849.         LLInventoryModel::findLostItems();
  1851. LLStartUp::setStartupState( STATE_PRECACHE );
  1852. timeout.reset();
  1853. return FALSE;
  1854. }
  1856. if (STATE_PRECACHE == LLStartUp::getStartupState())
  1857. {
  1858. F32 timeout_frac = timeout.getElapsedTimeF32()/PRECACHING_DELAY;
  1860. // We now have an inventory skeleton, so if this is a user's first
  1861. // login, we can start setting up their clothing and avatar 
  1862. // appearance.  This helps to avoid the generic "Ruth" avatar in
  1863. // the orientation island tutorial experience. JC
  1864. if (gAgent.isFirstLogin()
  1865. && !sInitialOutfit.empty()    // registration set up an outfit
  1866. && !sInitialOutfitGender.empty() // and a gender
  1867. && gAgent.getAvatarObject()   // can't wear clothes without object
  1868. && !gAgent.isGenderChosen() ) // nothing already loading
  1869. {
  1870. // Start loading the wearables, textures, gestures
  1871. LLStartUp::loadInitialOutfit( sInitialOutfit, sInitialOutfitGender );
  1872. }
  1874. // wait precache-delay and for agent's avatar or a lot longer.
  1875. if(((timeout_frac > 1.f) && gAgent.getAvatarObject())
  1876.    || (timeout_frac > 3.f))
  1877. {
  1878. LLStartUp::setStartupState( STATE_WEARABLES_WAIT );
  1879. }
  1880. else
  1881. {
  1882. update_texture_fetch();
  1883. set_startup_status(0.60f + 0.30f * timeout_frac,
  1884. LLTrans::getString("LoginPrecaching"),
  1885. gAgent.mMOTD);
  1886. display_startup();
  1887. if (!LLViewerShaderMgr::sInitialized)
  1888. {
  1889. LLViewerShaderMgr::sInitialized = TRUE;
  1890. LLViewerShaderMgr::instance()->setShaders();
  1891. }
  1892. }
  1894. return TRUE;
  1895. }
  1897. if (STATE_WEARABLES_WAIT == LLStartUp::getStartupState())
  1898. {
  1899. static LLFrameTimer wearables_timer;
  1901. const F32 wearables_time = wearables_timer.getElapsedTimeF32();
  1902. const F32 MAX_WEARABLES_TIME = 10.f;
  1904. if (!gAgent.isGenderChosen())
  1905. {
  1906. // No point in waiting for clothing, we don't even
  1907. // know what gender we are.  Pop a dialog to ask and
  1908. // proceed to draw the world. JC
  1909. //
  1910. // *NOTE: We might hit this case even if we have an
  1911. // initial outfit, but if the load hasn't started
  1912. // already then something is wrong so fall back
  1913. // to generic outfits. JC
  1914. LLNotificationsUtil::add("WelcomeChooseSex", LLSD(), LLSD(),
  1915. callback_choose_gender);
  1916. LLStartUp::setStartupState( STATE_CLEANUP );
  1917. return TRUE;
  1918. }
  1920. if (wearables_time > MAX_WEARABLES_TIME)
  1921. {
  1922. LLNotificationsUtil::add("ClothingLoading");
  1923. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_WEARABLES_TOO_LONG);
  1924. LLStartUp::setStartupState( STATE_CLEANUP );
  1925. return TRUE;
  1926. }
  1928. if (gAgent.isFirstLogin())
  1929. {
  1930. // wait for avatar to be completely loaded
  1931. if (gAgent.getAvatarObject()
  1932. && gAgent.getAvatarObject()->isFullyLoaded())
  1933. {
  1934. //llinfos << "avatar fully loaded" << llendl;
  1935. LLStartUp::setStartupState( STATE_CLEANUP );
  1936. return TRUE;
  1937. }
  1938. }
  1939. else
  1940. {
  1941. // OK to just get the wearables
  1942. if ( gAgentWearables.areWearablesLoaded() )
  1943. {
  1944. // We have our clothing, proceed.
  1945. //llinfos << "wearables loaded" << llendl;
  1946. LLStartUp::setStartupState( STATE_CLEANUP );
  1947. return TRUE;
  1948. }
  1949. }
  1951. update_texture_fetch();
  1952. set_startup_status(0.9f + 0.1f * wearables_time / MAX_WEARABLES_TIME,
  1953.  LLTrans::getString("LoginDownloadingClothing").c_str(),
  1954.  gAgent.mMOTD.c_str());
  1955. return TRUE;
  1956. }
  1958. if (STATE_CLEANUP == LLStartUp::getStartupState())
  1959. {
  1960. set_startup_status(1.0, "", "");
  1962. // Let the map know about the inventory.
  1963. LLFloaterWorldMap* floater_world_map = LLFloaterWorldMap::getInstance();
  1964. if(floater_world_map)
  1965. {
  1966. floater_world_map->observeInventory(&gInventory);
  1967. floater_world_map->observeFriends();
  1968. }
  1969. gViewerWindow->showCursor();
  1970. gViewerWindow->getWindow()->resetBusyCount();
  1971. gViewerWindow->getWindow()->setCursor(UI_CURSOR_ARROW);
  1972. LL_DEBUGS("AppInit") << "Done releasing bitmap" << LL_ENDL;
  1973. gViewerWindow->setShowProgress(FALSE);
  1974. gViewerWindow->setProgressCancelButtonVisible(FALSE);
  1976. // We're not away from keyboard, even though login might have taken
  1977. // a while. JC
  1978. gAgent.clearAFK();
  1980. // Have the agent start watching the friends list so we can update proxies
  1981. gAgent.observeFriends();
  1982. if (gSavedSettings.getBOOL("LoginAsGod"))
  1983. {
  1984. gAgent.requestEnterGodMode();
  1985. }
  1987. // Start automatic replay if the flag is set.
  1988. if (gSavedSettings.getBOOL("StatsAutoRun") || LLAgentPilot::sReplaySession)
  1989. {
  1990. LLUUID id;
  1991. LL_DEBUGS("AppInit") << "Starting automatic playback" << LL_ENDL;
  1992. gAgentPilot.startPlayback();
  1993. }
  1995. show_debug_menus(); // Debug menu visiblity and First Use trigger
  1997. // If we've got a startup URL, dispatch it
  1998. LLStartUp::dispatchURL();
  2000. // Retrieve information about the land data
  2001. // (just accessing this the first time will fetch it,
  2002. // then the data is cached for the viewer's lifetime)
  2003. LLProductInfoRequestManager::instance();
  2005. // *FIX:Mani - What do I do here?
  2006. // Need we really clear the Auth response data?
  2007. // Clean up the userauth stuff.
  2008. // LLUserAuth::getInstance()->reset();
  2010. LLStartUp::setStartupState( STATE_STARTED );
  2012. // Unmute audio if desired and setup volumes.
  2013. // Unmute audio if desired and setup volumes.
  2014. // This is a not-uncommon crash site, so surround it with
  2015. // llinfos output to aid diagnosis.
  2016. LL_INFOS("AppInit") << "Doing first audio_update_volume..." << LL_ENDL;
  2017. audio_update_volume();
  2018. LL_INFOS("AppInit") << "Done first audio_update_volume." << LL_ENDL;
  2020. // reset keyboard focus to sane state of pointing at world
  2021. gFocusMgr.setKeyboardFocus(NULL);
  2023. #if 0 // sjb: enable for auto-enabling timer display 
  2024. gDebugView->mFastTimerView->setVisible(TRUE);
  2025. #endif
  2027. LLAppViewer::instance()->handleLoginComplete();
  2029. // reset timers now that we are running "logged in" logic
  2030. LLFastTimer::reset();
  2032. LLAgentPicksInfo::getInstance()->requestNumberOfPicks();
  2034. LLIMFloater::initIMFloater();
  2036. return TRUE;
  2037. }
  2039. LL_WARNS("AppInit") << "Reached end of idle_startup for state " << LLStartUp::getStartupState() << LL_ENDL;
  2040. return TRUE;
  2041. }
  2043. //
  2044. // local function definition
  2045. //
  2047. void login_show()
  2048. {
  2049. LL_INFOS("AppInit") << "Initializing Login Screen" << LL_ENDL;
  2051. #ifdef LL_RELEASE_FOR_DOWNLOAD
  2052. BOOL bUseDebugLogin = gSavedSettings.getBOOL("UseDebugLogin");
  2053. #else
  2054. BOOL bUseDebugLogin = TRUE;
  2055. #endif
  2057. LLPanelLogin::show( gViewerWindow->getWindowRectScaled(),
  2058. bUseDebugLogin,
  2059. login_callback, NULL );
  2061. // UI textures have been previously loaded in doPreloadImages()
  2063. LL_DEBUGS("AppInit") << "Setting Servers" << LL_ENDL;
  2065. LLPanelLogin::addServer(LLViewerLogin::getInstance()->getGridLabel(), LLViewerLogin::getInstance()->getGridChoice());
  2067. LLViewerLogin* vl = LLViewerLogin::getInstance();
  2068. for(int grid_index = GRID_INFO_ADITI; grid_index < GRID_INFO_OTHER; ++grid_index)
  2069. {
  2070. LLPanelLogin::addServer(vl->getKnownGridLabel((EGridInfo)grid_index), grid_index);
  2071. }
  2072. }
  2074. // Callback for when login screen is closed.  Option 0 = connect, option 1 = quit.
  2075. void login_callback(S32 option, void *userdata)
  2076. {
  2077. const S32 CONNECT_OPTION = 0;
  2078. const S32 QUIT_OPTION = 1;
  2080. if (CONNECT_OPTION == option)
  2081. {
  2082. LLStartUp::setStartupState( STATE_LOGIN_CLEANUP );
  2083. return;
  2084. }
  2085. else if (QUIT_OPTION == option) // *TODO: THIS CODE SEEMS TO BE UNREACHABLE!!!!! login_callback is never called with option equal to QUIT_OPTION
  2086. {
  2087. // Make sure we don't save the password if the user is trying to clear it.
  2088. std::string first, last, password;
  2089. LLPanelLogin::getFields(&first, &last, &password);
  2090. if (!gSavedSettings.getBOOL("RememberPassword"))
  2091. {
  2092. // turn off the setting and write out to disk
  2093. gSavedSettings.saveToFile( gSavedSettings.getString("ClientSettingsFile") , TRUE );
  2094. LLUIColorTable::instance().saveUserSettings();
  2095. }
  2097. // Next iteration through main loop should shut down the app cleanly.
  2098. LLAppViewer::instance()->userQuit();
  2100. if (LLAppViewer::instance()->quitRequested())
  2101. {
  2102. LLPanelLogin::closePanel();
  2103. }
  2104. return;
  2105. }
  2106. else
  2107. {
  2108. LL_WARNS("AppInit") << "Unknown login button clicked" << LL_ENDL;
  2109. }
  2110. }
  2113. // static
  2114. std::string LLStartUp::loadPasswordFromDisk()
  2115. {
  2116. // Only load password if we also intend to save it (otherwise the user
  2117. // wonders what we're doing behind his back).  JC
  2118. BOOL remember_password = gSavedSettings.getBOOL("RememberPassword");
  2119. if (!remember_password)
  2120. {
  2121. return std::string("");
  2122. }
  2124. std::string hashed_password("");
  2126. // Look for legacy "marker" password from settings.ini
  2127. hashed_password = gSavedSettings.getString("Marker");
  2128. if (!hashed_password.empty())
  2129. {
  2130. // Stomp the Marker entry.
  2131. gSavedSettings.setString("Marker", "");
  2133. // Return that password.
  2134. return hashed_password;
  2135. }
  2137. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,
  2138.    "password.dat");
  2139. LLFILE* fp = LLFile::fopen(filepath, "rb"); /* Flawfinder: ignore */
  2140. if (!fp)
  2141. {
  2142. return hashed_password;
  2143. }
  2145. // UUID is 16 bytes, written into ASCII is 32 characters
  2146. // without trailing 
  2147. const S32 HASHED_LENGTH = 32;
  2148. U8 buffer[HASHED_LENGTH+1];
  2150. if (1 != fread(buffer, HASHED_LENGTH, 1, fp))
  2151. {
  2152. return hashed_password;
  2153. }
  2155. fclose(fp);
  2157. // Decipher with MAC address
  2158. LLXORCipher cipher(gMACAddress, 6);
  2159. cipher.decrypt(buffer, HASHED_LENGTH);
  2161. buffer[HASHED_LENGTH] = '';
  2163. // Check to see if the mac address generated a bad hashed
  2164. // password. It should be a hex-string or else the mac adress has
  2165. // changed. This is a security feature to make sure that if you
  2166. // get someone's password.dat file, you cannot hack their account.
  2167. if(is_hex_string(buffer, HASHED_LENGTH))
  2168. {
  2169. hashed_password.assign((char*)buffer);
  2170. }
  2172. return hashed_password;
  2173. }
  2176. // static
  2177. void LLStartUp::savePasswordToDisk(const std::string& hashed_password)
  2178. {
  2179. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,
  2180.    "password.dat");
  2181. LLFILE* fp = LLFile::fopen(filepath, "wb"); /* Flawfinder: ignore */
  2182. if (!fp)
  2183. {
  2184. return;
  2185. }
  2187. // Encipher with MAC address
  2188. const S32 HASHED_LENGTH = 32;
  2189. U8 buffer[HASHED_LENGTH+1];
  2191. LLStringUtil::copy((char*)buffer, hashed_password.c_str(), HASHED_LENGTH+1);
  2193. LLXORCipher cipher(gMACAddress, 6);
  2194. cipher.encrypt(buffer, HASHED_LENGTH);
  2196. if (fwrite(buffer, HASHED_LENGTH, 1, fp) != 1)
  2197. {
  2198. LL_WARNS("AppInit") << "Short write" << LL_ENDL;
  2199. }
  2201. fclose(fp);
  2202. }
  2205. // static
  2206. void LLStartUp::deletePasswordFromDisk()
  2207. {
  2208. std::string filepath = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,
  2209.   "password.dat");
  2210. LLFile::remove(filepath);
  2211. }
  2214. bool is_hex_string(U8* str, S32 len)
  2215. {
  2216. bool rv = true;
  2217. U8* c = str;
  2218. while(rv && len--)
  2219. {
  2220. switch(*c)
  2221. {
  2222. case '0':
  2223. case '1':
  2224. case '2':
  2225. case '3':
  2226. case '4':
  2227. case '5':
  2228. case '6':
  2229. case '7':
  2230. case '8':
  2231. case '9':
  2232. case 'a':
  2233. case 'b':
  2234. case 'c':
  2235. case 'd':
  2236. case 'e':
  2237. case 'f':
  2238. ++c;
  2239. break;
  2240. default:
  2241. rv = false;
  2242. break;
  2243. }
  2244. }
  2245. return rv;
  2246. }
  2248. void show_first_run_dialog()
  2249. {
  2250. LLNotificationsUtil::add("FirstRun", LLSD(), LLSD(), first_run_dialog_callback);
  2251. }
  2253. bool first_run_dialog_callback(const LLSD& notification, const LLSD& response)
  2254. {
  2255. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2256. if (0 == option)
  2257. {
  2258. LL_DEBUGS("AppInit") << "First run dialog cancelling" << LL_ENDL;
  2259. LLWeb::loadURLExternal(LLTrans::getString("create_account_url") );
  2260. }
  2262. LLPanelLogin::giveFocus();
  2263. return false;
  2264. }
  2268. void set_startup_status(const F32 frac, const std::string& string, const std::string& msg)
  2269. {
  2270. gViewerWindow->setProgressPercent(frac*100);
  2271. gViewerWindow->setProgressString(string);
  2273. gViewerWindow->setProgressMessage(msg);
  2274. }
  2276. bool login_alert_status(const LLSD& notification, const LLSD& response)
  2277. {
  2278. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2279.     // Buttons
  2280.     switch( option )
  2281.     {
  2282.         case 0:     // OK
  2283.             break;
  2284.       //  case 1:     // Help
  2285.       //      LLWeb::loadURL(LLNotifications::instance().getGlobalString("SUPPORT_URL") );
  2286.       //      break;
  2287.         case 2:     // Teleport
  2288.             // Restart the login process, starting at our home locaton
  2289.             LLURLSimString::setString("home");
  2290.             LLStartUp::setStartupState( STATE_LOGIN_CLEANUP );
  2291.             break;
  2292.         default:
  2293.             LL_WARNS("AppInit") << "Missing case in login_alert_status switch" << LL_ENDL;
  2294.     }
  2296. LLPanelLogin::giveFocus();
  2297. return false;
  2298. }
  2301. void use_circuit_callback(void**, S32 result)
  2302. {
  2303. // bail if we're quitting.
  2304. if(LLApp::isExiting()) return;
  2305. if( !gUseCircuitCallbackCalled )
  2306. {
  2307. gUseCircuitCallbackCalled = true;
  2308. if (result)
  2309. {
  2310. // Make sure user knows something bad happened. JC
  2311. LL_WARNS("AppInit") << "Backing up to login screen!" << LL_ENDL;
  2312. LLNotificationsUtil::add("LoginPacketNeverReceived", LLSD(), LLSD(), login_alert_status);
  2313. reset_login();
  2314. }
  2315. else
  2316. {
  2317. gGotUseCircuitCodeAck = true;
  2318. }
  2319. }
  2320. }
  2322. void register_viewer_callbacks(LLMessageSystem* msg)
  2323. {
  2324. msg->setHandlerFuncFast(_PREHASH_LayerData, process_layer_data );
  2325. msg->setHandlerFuncFast(_PREHASH_ImageData, LLViewerTextureList::receiveImageHeader );
  2326. msg->setHandlerFuncFast(_PREHASH_ImagePacket, LLViewerTextureList::receiveImagePacket );
  2327. msg->setHandlerFuncFast(_PREHASH_ObjectUpdate, process_object_update );
  2328. msg->setHandlerFunc("ObjectUpdateCompressed", process_compressed_object_update );
  2329. msg->setHandlerFunc("ObjectUpdateCached", process_cached_object_update );
  2330. msg->setHandlerFuncFast(_PREHASH_ImprovedTerseObjectUpdate, process_terse_object_update_improved );
  2331. msg->setHandlerFunc("SimStats", process_sim_stats);
  2332. msg->setHandlerFuncFast(_PREHASH_HealthMessage, process_health_message );
  2333. msg->setHandlerFuncFast(_PREHASH_EconomyData, process_economy_data);
  2334. msg->setHandlerFunc("RegionInfo", LLViewerRegion::processRegionInfo);
  2336. msg->setHandlerFuncFast(_PREHASH_ChatFromSimulator, process_chat_from_simulator);
  2337. msg->setHandlerFuncFast(_PREHASH_KillObject, process_kill_object, NULL);
  2338. msg->setHandlerFuncFast(_PREHASH_SimulatorViewerTimeMessage, process_time_synch, NULL);
  2339. msg->setHandlerFuncFast(_PREHASH_EnableSimulator, process_enable_simulator);
  2340. msg->setHandlerFuncFast(_PREHASH_DisableSimulator, process_disable_simulator);
  2341. msg->setHandlerFuncFast(_PREHASH_KickUser, process_kick_user, NULL);
  2343. msg->setHandlerFunc("CrossedRegion", process_crossed_region);
  2344. msg->setHandlerFuncFast(_PREHASH_TeleportFinish, process_teleport_finish);
  2346. msg->setHandlerFuncFast(_PREHASH_AlertMessage,             process_alert_message);
  2347. msg->setHandlerFunc("AgentAlertMessage", process_agent_alert_message);
  2348. msg->setHandlerFuncFast(_PREHASH_MeanCollisionAlert,             process_mean_collision_alert_message,  NULL);
  2349. msg->setHandlerFunc("ViewerFrozenMessage",             process_frozen_message);
  2351. msg->setHandlerFuncFast(_PREHASH_NameValuePair, process_name_value);
  2352. msg->setHandlerFuncFast(_PREHASH_RemoveNameValuePair, process_remove_name_value);
  2353. msg->setHandlerFuncFast(_PREHASH_AvatarAnimation, process_avatar_animation);
  2354. msg->setHandlerFuncFast(_PREHASH_AvatarAppearance, process_avatar_appearance);
  2355. msg->setHandlerFunc("AgentCachedTextureResponse", LLAgent::processAgentCachedTextureResponse);
  2356. msg->setHandlerFunc("RebakeAvatarTextures", LLVOAvatarSelf::processRebakeAvatarTextures);
  2357. msg->setHandlerFuncFast(_PREHASH_CameraConstraint, process_camera_constraint);
  2358. msg->setHandlerFuncFast(_PREHASH_AvatarSitResponse, process_avatar_sit_response);
  2359. msg->setHandlerFunc("SetFollowCamProperties", process_set_follow_cam_properties);
  2360. msg->setHandlerFunc("ClearFollowCamProperties", process_clear_follow_cam_properties);
  2362. msg->setHandlerFuncFast(_PREHASH_ImprovedInstantMessage, process_improved_im);
  2363. msg->setHandlerFuncFast(_PREHASH_ScriptQuestion, process_script_question);
  2364. msg->setHandlerFuncFast(_PREHASH_ObjectProperties, LLSelectMgr::processObjectProperties, NULL);
  2365. msg->setHandlerFuncFast(_PREHASH_ObjectPropertiesFamily, LLSelectMgr::processObjectPropertiesFamily, NULL);
  2366. msg->setHandlerFunc("ForceObjectSelect", LLSelectMgr::processForceObjectSelect);
  2368. msg->setHandlerFuncFast(_PREHASH_MoneyBalanceReply, process_money_balance_reply, NULL);
  2369. msg->setHandlerFuncFast(_PREHASH_CoarseLocationUpdate, LLWorld::processCoarseUpdate, NULL);
  2370. msg->setHandlerFuncFast(_PREHASH_ReplyTaskInventory,  LLViewerObject::processTaskInv, NULL);
  2371. msg->setHandlerFuncFast(_PREHASH_DerezContainer, process_derez_container, NULL);
  2372. msg->setHandlerFuncFast(_PREHASH_ScriptRunningReply,
  2373. &LLLiveLSLEditor::processScriptRunningReply);
  2375. msg->setHandlerFuncFast(_PREHASH_DeRezAck, process_derez_ack);
  2377. msg->setHandlerFunc("LogoutReply", process_logout_reply);
  2379. //msg->setHandlerFuncFast(_PREHASH_AddModifyAbility,
  2380. // &LLAgent::processAddModifyAbility);
  2381. //msg->setHandlerFuncFast(_PREHASH_RemoveModifyAbility,
  2382. // &LLAgent::processRemoveModifyAbility);
  2383. msg->setHandlerFuncFast(_PREHASH_AgentDataUpdate,
  2384. &LLAgent::processAgentDataUpdate);
  2385. msg->setHandlerFuncFast(_PREHASH_AgentGroupDataUpdate,
  2386. &LLAgent::processAgentGroupDataUpdate);
  2387. msg->setHandlerFunc("AgentDropGroup",
  2388. &LLAgent::processAgentDropGroup);
  2389. // land ownership messages
  2390. msg->setHandlerFuncFast(_PREHASH_ParcelOverlay,
  2391. LLViewerParcelMgr::processParcelOverlay);
  2392. msg->setHandlerFuncFast(_PREHASH_ParcelProperties,
  2393. LLViewerParcelMgr::processParcelProperties);
  2394. msg->setHandlerFunc("ParcelAccessListReply",
  2395. LLViewerParcelMgr::processParcelAccessListReply);
  2396. msg->setHandlerFunc("ParcelDwellReply",
  2397. LLViewerParcelMgr::processParcelDwellReply);
  2399. msg->setHandlerFunc("AvatarPropertiesReply",
  2400. &LLAvatarPropertiesProcessor::processAvatarPropertiesReply);
  2401. msg->setHandlerFunc("AvatarInterestsReply",
  2402. &LLAvatarPropertiesProcessor::processAvatarInterestsReply);
  2403. msg->setHandlerFunc("AvatarGroupsReply",
  2404. &LLAvatarPropertiesProcessor::processAvatarGroupsReply);
  2405. // ratings deprecated
  2406. //msg->setHandlerFuncFast(_PREHASH_AvatarStatisticsReply,
  2407. // LLPanelAvatar::processAvatarStatisticsReply);
  2408. msg->setHandlerFunc("AvatarNotesReply",
  2409. &LLAvatarPropertiesProcessor::processAvatarNotesReply);
  2410. msg->setHandlerFunc("AvatarPicksReply",
  2411. &LLAvatarPropertiesProcessor::processAvatarPicksReply);
  2412.   msg->setHandlerFunc("AvatarClassifiedReply",
  2413.   &LLAvatarPropertiesProcessor::processAvatarClassifiedsReply);
  2415. msg->setHandlerFuncFast(_PREHASH_CreateGroupReply,
  2416. LLGroupMgr::processCreateGroupReply);
  2417. msg->setHandlerFuncFast(_PREHASH_JoinGroupReply,
  2418. LLGroupMgr::processJoinGroupReply);
  2419. msg->setHandlerFuncFast(_PREHASH_EjectGroupMemberReply,
  2420. LLGroupMgr::processEjectGroupMemberReply);
  2421. msg->setHandlerFuncFast(_PREHASH_LeaveGroupReply,
  2422. LLGroupMgr::processLeaveGroupReply);
  2423. msg->setHandlerFuncFast(_PREHASH_GroupProfileReply,
  2424. LLGroupMgr::processGroupPropertiesReply);
  2426. // ratings deprecated
  2427. // msg->setHandlerFuncFast(_PREHASH_ReputationIndividualReply,
  2428. // LLFloaterRate::processReputationIndividualReply);
  2430. msg->setHandlerFuncFast(_PREHASH_AgentWearablesUpdate,
  2431. LLAgentWearables::processAgentInitialWearablesUpdate );
  2433. msg->setHandlerFunc("ScriptControlChange",
  2434. LLAgent::processScriptControlChange );
  2436. msg->setHandlerFuncFast(_PREHASH_ViewerEffect, LLHUDManager::processViewerEffect);
  2438. msg->setHandlerFuncFast(_PREHASH_GrantGodlikePowers, process_grant_godlike_powers);
  2440. msg->setHandlerFuncFast(_PREHASH_GroupAccountSummaryReply,
  2441. LLPanelGroupLandMoney::processGroupAccountSummaryReply);
  2442. msg->setHandlerFuncFast(_PREHASH_GroupAccountDetailsReply,
  2443. LLPanelGroupLandMoney::processGroupAccountDetailsReply);
  2444. msg->setHandlerFuncFast(_PREHASH_GroupAccountTransactionsReply,
  2445. LLPanelGroupLandMoney::processGroupAccountTransactionsReply);
  2447. msg->setHandlerFuncFast(_PREHASH_UserInfoReply,
  2448. process_user_info_reply);
  2450. msg->setHandlerFunc("RegionHandshake", process_region_handshake, NULL);
  2452. msg->setHandlerFunc("TeleportStart", process_teleport_start );
  2453. msg->setHandlerFunc("TeleportProgress", process_teleport_progress);
  2454. msg->setHandlerFunc("TeleportFailed", process_teleport_failed, NULL);
  2455. msg->setHandlerFunc("TeleportLocal", process_teleport_local, NULL);
  2457. msg->setHandlerFunc("ImageNotInDatabase", LLViewerTextureList::processImageNotInDatabase, NULL);
  2459. msg->setHandlerFuncFast(_PREHASH_GroupMembersReply,
  2460. LLGroupMgr::processGroupMembersReply);
  2461. msg->setHandlerFunc("GroupRoleDataReply",
  2462. LLGroupMgr::processGroupRoleDataReply);
  2463. msg->setHandlerFunc("GroupRoleMembersReply",
  2464. LLGroupMgr::processGroupRoleMembersReply);
  2465. msg->setHandlerFunc("GroupTitlesReply",
  2466. LLGroupMgr::processGroupTitlesReply);
  2467. // Special handler as this message is sometimes used for group land.
  2468. msg->setHandlerFunc("PlacesReply", process_places_reply);
  2469. msg->setHandlerFunc("GroupNoticesListReply", LLPanelGroupNotices::processGroupNoticesListReply);
  2471. msg->setHandlerFunc("AvatarPickerReply", LLFloaterAvatarPicker::processAvatarPickerReply);
  2473. msg->setHandlerFunc("MapBlockReply", LLWorldMapMessage::processMapBlockReply);
  2474. msg->setHandlerFunc("MapItemReply", LLWorldMapMessage::processMapItemReply);
  2476. msg->setHandlerFunc("EventInfoReply", LLFloaterEvent::processEventInfoReply);
  2477. msg->setHandlerFunc("PickInfoReply", &LLAvatarPropertiesProcessor::processPickInfoReply);
  2478. // msg->setHandlerFunc("ClassifiedInfoReply", LLPanelClassified::processClassifiedInfoReply);
  2479. msg->setHandlerFunc("ClassifiedInfoReply", LLAvatarPropertiesProcessor::processClassifiedInfoReply);
  2480. msg->setHandlerFunc("ParcelInfoReply", LLRemoteParcelInfoProcessor::processParcelInfoReply);
  2481. msg->setHandlerFunc("ScriptDialog", process_script_dialog);
  2482. msg->setHandlerFunc("LoadURL", process_load_url);
  2483. msg->setHandlerFunc("ScriptTeleportRequest", process_script_teleport_request);
  2484. msg->setHandlerFunc("EstateCovenantReply", process_covenant_reply);
  2486. // calling cards
  2487. msg->setHandlerFunc("OfferCallingCard", process_offer_callingcard);
  2488. msg->setHandlerFunc("AcceptCallingCard", process_accept_callingcard);
  2489. msg->setHandlerFunc("DeclineCallingCard", process_decline_callingcard);
  2491. msg->setHandlerFunc("ParcelObjectOwnersReply", LLPanelLandObjects::processParcelObjectOwnersReply);
  2493. msg->setHandlerFunc("InitiateDownload", process_initiate_download);
  2494. msg->setHandlerFunc("LandStatReply", LLFloaterTopObjects::handle_land_reply);
  2495. msg->setHandlerFunc("GenericMessage", process_generic_message);
  2497. msg->setHandlerFuncFast(_PREHASH_FeatureDisabled, process_feature_disabled_message);
  2498. }
  2500. void asset_callback_nothing(LLVFS*, const LLUUID&, LLAssetType::EType, void*, S32)
  2501. {
  2502. // nothing
  2503. }
  2505. // *HACK: Must match name in Library or agent inventory
  2506. const std::string COMMON_GESTURES_FOLDER = "Common Gestures";
  2507. const std::string MALE_GESTURES_FOLDER = "Male Gestures";
  2508. const std::string FEMALE_GESTURES_FOLDER = "Female Gestures";
  2509. const std::string MALE_OUTFIT_FOLDER = "Male Shape & Outfit";
  2510. const std::string FEMALE_OUTFIT_FOLDER = "Female Shape & Outfit";
  2511. const S32 OPT_CLOSED_WINDOW = -1;
  2512. const S32 OPT_MALE = 0;
  2513. const S32 OPT_FEMALE = 1;
  2515. bool callback_choose_gender(const LLSD& notification, const LLSD& response)
  2516. {
  2517. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2518. switch(option)
  2519. {
  2520. case OPT_MALE:
  2521. LLStartUp::loadInitialOutfit( MALE_OUTFIT_FOLDER, "male" );
  2522. break;
  2524. case OPT_FEMALE:
  2525. case OPT_CLOSED_WINDOW:
  2526. default:
  2527. LLStartUp::loadInitialOutfit( FEMALE_OUTFIT_FOLDER, "female" );
  2528. break;
  2529. }
  2530. return false;
  2531. }
  2533. void LLStartUp::loadInitialOutfit( const std::string& outfit_folder_name,
  2534.    const std::string& gender_name )
  2535. {
  2536. llinfos << "starting" << llendl;
  2538. // Not going through the processAgentInitialWearables path, so need to set this here.
  2539. LLAppearanceManager::instance().setAttachmentInvLinkEnable(true);
  2540. // Initiate creation of COF, since we're also bypassing that.
  2541. gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
  2543. S32 gender = 0;
  2544. std::string gestures;
  2545. if (gender_name == "male")
  2546. {
  2547. gender = OPT_MALE;
  2548. gestures = MALE_GESTURES_FOLDER;
  2549. }
  2550. else
  2551. {
  2552. gender = OPT_FEMALE;
  2553. gestures = FEMALE_GESTURES_FOLDER;
  2554. }
  2556. // try to find the outfit - if not there, create some default
  2557. // wearables.
  2558. LLUUID cat_id = findDescendentCategoryIDByName(
  2559. gInventory.getLibraryRootFolderID(),
  2560. outfit_folder_name);
  2561. if (cat_id.isNull())
  2562. {
  2563. gAgentWearables.createStandardWearables(gender);
  2564. }
  2565. else
  2566. {
  2567. bool do_copy = true;
  2568. bool do_append = false;
  2569. LLViewerInventoryCategory *cat = gInventory.getCategory(cat_id);
  2570. LLAppearanceManager::instance().wearInventoryCategory(cat, do_copy, do_append);
  2571. }
  2573. // Copy gestures
  2574. LLUUID dst_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
  2575. LLPointer<LLInventoryCallback> cb(NULL);
  2576. LLAppearanceManager *app_mgr = &(LLAppearanceManager::instance());
  2578. // - Copy gender-specific gestures.
  2579. LLUUID gestures_cat_id = findDescendentCategoryIDByName( 
  2580. gInventory.getLibraryRootFolderID(),
  2581. gestures);
  2582. if (gestures_cat_id.notNull())
  2583. {
  2584. callAfterCategoryFetch(gestures_cat_id,
  2585.    boost::bind(&LLAppearanceManager::shallowCopyCategory,
  2586.    app_mgr,
  2587.    gestures_cat_id,
  2588.    dst_id,
  2589.    cb));
  2590. }
  2592. // - Copy common gestures.
  2593. LLUUID common_gestures_cat_id = findDescendentCategoryIDByName( 
  2594. gInventory.getLibraryRootFolderID(),
  2595. COMMON_GESTURES_FOLDER);
  2596. if (common_gestures_cat_id.notNull())
  2597. {
  2598. callAfterCategoryFetch(common_gestures_cat_id,
  2599.    boost::bind(&LLAppearanceManager::shallowCopyCategory,
  2600.    app_mgr,
  2601.    common_gestures_cat_id,
  2602.    dst_id,
  2603.    cb));
  2604. }
  2606. // This is really misnamed -- it means we have started loading
  2607. // an outfit/shape that will give the avatar a gender eventually. JC
  2608. gAgent.setGenderChosen(TRUE);
  2610. }
  2612. // Loads a bitmap to display during load
  2613. void init_start_screen(S32 location_id)
  2614. {
  2615. if (gStartTexture.notNull())
  2616. {
  2617. gStartTexture = NULL;
  2618. LL_INFOS("AppInit") << "re-initializing start screen" << LL_ENDL;
  2619. }
  2621. LL_DEBUGS("AppInit") << "Loading startup bitmap..." << LL_ENDL;
  2623. std::string temp_str = gDirUtilp->getLindenUserDir() + gDirUtilp->getDirDelimiter();
  2625. if ((S32)START_LOCATION_ID_LAST == location_id)
  2626. {
  2627. temp_str += SCREEN_LAST_FILENAME;
  2628. }
  2629. else
  2630. {
  2631. temp_str += SCREEN_HOME_FILENAME;
  2632. }
  2634. LLPointer<LLImageBMP> start_image_bmp = new LLImageBMP;
  2636. // Turn off start screen to get around the occasional readback 
  2637. // driver bug
  2638. if(!gSavedSettings.getBOOL("UseStartScreen"))
  2639. {
  2640. LL_INFOS("AppInit")  << "Bitmap load disabled" << LL_ENDL;
  2641. return;
  2642. }
  2643. else if(!start_image_bmp->load(temp_str) )
  2644. {
  2645. LL_WARNS("AppInit") << "Bitmap load failed" << LL_ENDL;
  2646. return;
  2647. }
  2649. gStartImageWidth = start_image_bmp->getWidth();
  2650. gStartImageHeight = start_image_bmp->getHeight();
  2652. LLPointer<LLImageRaw> raw = new LLImageRaw;
  2653. if (!start_image_bmp->decode(raw, 0.0f))
  2654. {
  2655. LL_WARNS("AppInit") << "Bitmap decode failed" << LL_ENDL;
  2656. gStartTexture = NULL;
  2657. return;
  2658. }
  2660. raw->expandToPowerOfTwo();
  2661. gStartTexture = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE) ;
  2662. }
  2665. // frees the bitmap
  2666. void release_start_screen()
  2667. {
  2668. LL_DEBUGS("AppInit") << "Releasing bitmap..." << LL_ENDL;
  2669. gStartTexture = NULL;
  2670. }
  2673. // static
  2674. std::string LLStartUp::startupStateToString(EStartupState state)
  2675. {
  2676. #define RTNENUM(E) case E: return #E
  2677. switch(state){
  2678. RTNENUM( STATE_FIRST );
  2679. RTNENUM( STATE_BROWSER_INIT );
  2680. RTNENUM( STATE_LOGIN_SHOW );
  2681. RTNENUM( STATE_LOGIN_WAIT );
  2682. RTNENUM( STATE_LOGIN_CLEANUP );
  2683. RTNENUM( STATE_LOGIN_AUTH_INIT );
  2684. RTNENUM( STATE_LOGIN_CURL_UNSTUCK );
  2685. RTNENUM( STATE_LOGIN_PROCESS_RESPONSE );
  2686. RTNENUM( STATE_WORLD_INIT );
  2687. RTNENUM( STATE_MULTIMEDIA_INIT );
  2688. RTNENUM( STATE_FONT_INIT );
  2689. RTNENUM( STATE_SEED_GRANTED_WAIT );
  2690. RTNENUM( STATE_SEED_CAP_GRANTED );
  2691. RTNENUM( STATE_WORLD_WAIT );
  2692. RTNENUM( STATE_AGENT_SEND );
  2693. RTNENUM( STATE_AGENT_WAIT );
  2694. RTNENUM( STATE_INVENTORY_SEND );
  2695. RTNENUM( STATE_MISC );
  2696. RTNENUM( STATE_PRECACHE );
  2697. RTNENUM( STATE_WEARABLES_WAIT );
  2698. RTNENUM( STATE_CLEANUP );
  2699. RTNENUM( STATE_STARTED );
  2700. default:
  2701. return llformat("(state #%d)", state);
  2702. }
  2703. #undef RTNENUM
  2704. }
  2706. // static
  2707. void LLStartUp::setStartupState( EStartupState state )
  2708. {
  2709. LL_INFOS("AppInit") << "Startup state changing from " <<  
  2710. getStartupStateString() << " to " <<  
  2711. startupStateToString(state) << LL_ENDL;
  2712. gStartupState = state;
  2713. postStartupState();
  2714. }
  2716. void LLStartUp::postStartupState()
  2717. {
  2718. LLSD stateInfo;
  2719. stateInfo["str"] = getStartupStateString();
  2720. stateInfo["enum"] = gStartupState;
  2721. sStateWatcher->post(stateInfo);
  2722. }
  2725. void reset_login()
  2726. {
  2727. gAgent.cleanup();
  2728. LLWorld::getInstance()->destroyClass();
  2730. LLStartUp::setStartupState( STATE_LOGIN_SHOW );
  2732. if ( gViewerWindow )
  2733. { // Hide menus and normal buttons
  2734. gViewerWindow->setNormalControlsVisible( FALSE );
  2735. gLoginMenuBarView->setVisible( TRUE );
  2736. gLoginMenuBarView->setEnabled( TRUE );
  2737. }
  2739. // Hide any other stuff
  2740. LLFloaterReg::hideVisibleInstances();
  2741. }
  2743. //---------------------------------------------------------------------------
  2745. std::string LLStartUp::sSLURLCommand;
  2747. bool LLStartUp::canGoFullscreen()
  2748. {
  2749. return gStartupState >= STATE_WORLD_INIT;
  2750. }
  2752. // Initialize all plug-ins except the web browser (which was initialized
  2753. // early, before the login screen). JC
  2754. void LLStartUp::multimediaInit()
  2755. {
  2756. LL_DEBUGS("AppInit") << "Initializing Multimedia...." << LL_ENDL;
  2757. std::string msg = LLTrans::getString("LoginInitializingMultimedia");
  2758. set_startup_status(0.42f, msg.c_str(), gAgent.mMOTD.c_str());
  2759. display_startup();
  2761. // LLViewerMedia::initClass();
  2762. LLViewerParcelMedia::initClass();
  2763. }
  2765. void LLStartUp::fontInit()
  2766. {
  2767. LL_DEBUGS("AppInit") << "Initializing fonts...." << LL_ENDL;
  2768. std::string msg = LLTrans::getString("LoginInitializingFonts");
  2769. set_startup_status(0.45f, msg.c_str(), gAgent.mMOTD.c_str());
  2770. display_startup();
  2772. LLFontGL::loadDefaultFonts();
  2773. }
  2775. bool LLStartUp::dispatchURL()
  2776. {
  2777. // ok, if we've gotten this far and have a startup URL
  2778. if (!sSLURLCommand.empty())
  2779. {
  2780. LLMediaCtrl* web = NULL;
  2781. const bool trusted_browser = false;
  2782. LLURLDispatcher::dispatch(sSLURLCommand, web, trusted_browser);
  2783. }
  2784. else if (LLURLSimString::parse())
  2785. {
  2786. // If we started with a location, but we're already
  2787. // at that location, don't pop dialogs open.
  2788. LLVector3 pos = gAgent.getPositionAgent();
  2789. F32 dx = pos.mV[VX] - (F32)LLURLSimString::sInstance.mX;
  2790. F32 dy = pos.mV[VY] - (F32)LLURLSimString::sInstance.mY;
  2791. const F32 SLOP = 2.f; // meters
  2793. if( LLURLSimString::sInstance.mSimName != gAgent.getRegion()->getName()
  2794. || (dx*dx > SLOP*SLOP)
  2795. || (dy*dy > SLOP*SLOP) )
  2796. {
  2797. std::string url = LLURLSimString::getURL();
  2798. LLMediaCtrl* web = NULL;
  2799. const bool trusted_browser = false;
  2800. LLURLDispatcher::dispatch(url, web, trusted_browser);
  2801. }
  2802. return true;
  2803. }
  2804. return false;
  2805. }
  2807. bool login_alert_done(const LLSD& notification, const LLSD& response)
  2808. {
  2809. LLPanelLogin::giveFocus();
  2810. return false;
  2811. }
  2814. void apply_udp_blacklist(const std::string& csv)
  2815. {
  2817. std::string::size_type start = 0;
  2818. std::string::size_type comma = 0;
  2819. do 
  2820. {
  2821. comma = csv.find(",", start);
  2822. if (comma == std::string::npos)
  2823. {
  2824. comma = csv.length();
  2825. }
  2826. std::string item(csv, start, comma-start);
  2828. lldebugs << "udp_blacklist " << item << llendl;
  2829. gMessageSystem->banUdpMessage(item);
  2831. start = comma + 1;
  2833. }
  2834. while(comma < csv.length());
  2836. }
  2838. bool process_login_success_response()
  2839. {
  2840. LLSD response = LLLoginInstance::getInstance()->getResponse();
  2842. std::string text(response["udp_blacklist"]);
  2843. if(!text.empty())
  2844. {
  2845. apply_udp_blacklist(text);
  2846. }
  2848. // unpack login data needed by the application
  2849. text = response["agent_id"].asString();
  2850. if(!text.empty()) gAgentID.set(text);
  2851. gDebugInfo["AgentID"] = text;
  2853. text = response["session_id"].asString();
  2854. if(!text.empty()) gAgentSessionID.set(text);
  2855. gDebugInfo["SessionID"] = text;
  2857. text = response["secure_session_id"].asString();
  2858. if(!text.empty()) gAgent.mSecureSessionID.set(text);
  2860. text = response["first_name"].asString();
  2861. if(!text.empty()) 
  2862. {
  2863. // Remove quotes from string.  Login.cgi sends these to force
  2864. // names that look like numbers into strings.
  2865. gFirstname.assign(text);
  2866. LLStringUtil::replaceChar(gFirstname, '"', ' ');
  2867. LLStringUtil::trim(gFirstname);
  2868. }
  2869. text = response["last_name"].asString();
  2870. if(!text.empty()) 
  2871. {
  2872. gLastname.assign(text);
  2873. }
  2874. gSavedSettings.setString("FirstName", gFirstname);
  2875. gSavedSettings.setString("LastName", gLastname);
  2877. if (gSavedSettings.getBOOL("RememberPassword"))
  2878. {
  2879. // Successful login means the password is valid, so save it.
  2880. LLStartUp::savePasswordToDisk(gPassword);
  2881. }
  2882. else
  2883. {
  2884. // Don't leave password from previous session sitting around
  2885. // during this login session.
  2886. LLStartUp::deletePasswordFromDisk();
  2887. }
  2889. // this is their actual ability to access content
  2890. text = response["agent_access_max"].asString();
  2891. if (!text.empty())
  2892. {
  2893. // agent_access can be 'A', 'M', and 'PG'.
  2894. gAgent.setMaturity(text[0]);
  2895. }
  2897. // this is the value of their preference setting for that content
  2898. // which will always be <= agent_access_max
  2899. text = response["agent_region_access"].asString();
  2900. if (!text.empty())
  2901. {
  2902. U32 preferredMaturity =
  2903. llmin((U32)LLAgent::convertTextToMaturity(text[0]),
  2904.       gSavedSettings.getU32("PreferredMaturity"));
  2905. gSavedSettings.setU32("PreferredMaturity", preferredMaturity);
  2906. }
  2907. // During the AO transition, this flag will be true. Then the flag will
  2908. // go away. After the AO transition, this code and all the code that
  2909. // uses it can be deleted.
  2910. text = response["ao_transition"].asString();
  2911. if (!text.empty())
  2912. {
  2913. if (text == "1")
  2914. {
  2915. gAgent.setAOTransition();
  2916. }
  2917. }
  2919. text = response["start_location"].asString();
  2920. if(!text.empty()) 
  2921. {
  2922. gAgentStartLocation.assign(text);
  2923. }
  2925. text = response["circuit_code"].asString();
  2926. if(!text.empty())
  2927. {
  2928. gMessageSystem->mOurCircuitCode = strtoul(text.c_str(), NULL, 10);
  2929. }
  2930. std::string sim_ip_str = response["sim_ip"];
  2931. std::string sim_port_str = response["sim_port"];
  2932. if(!sim_ip_str.empty() && !sim_port_str.empty())
  2933. {
  2934. U32 sim_port = strtoul(sim_port_str.c_str(), NULL, 10);
  2935. gFirstSim.set(sim_ip_str, sim_port);
  2936. if (gFirstSim.isOk())
  2937. {
  2938. gMessageSystem->enableCircuit(gFirstSim, TRUE);
  2939. }
  2940. }
  2941. std::string region_x_str = response["region_x"];
  2942. std::string region_y_str = response["region_y"];
  2943. if(!region_x_str.empty() && !region_y_str.empty())
  2944. {
  2945. U32 region_x = strtoul(region_x_str.c_str(), NULL, 10);
  2946. U32 region_y = strtoul(region_y_str.c_str(), NULL, 10);
  2947. gFirstSimHandle = to_region_handle(region_x, region_y);
  2948. }
  2950. const std::string look_at_str = response["look_at"];
  2951. if (!look_at_str.empty())
  2952. {
  2953. size_t len = look_at_str.size();
  2954. LLMemoryStream mstr((U8*)look_at_str.c_str(), len);
  2955. LLSD sd = LLSDSerialize::fromNotation(mstr, len);
  2956. gAgentStartLookAt = ll_vector3_from_sd(sd);
  2957. }
  2959. text = response["seed_capability"].asString();
  2960. if (!text.empty()) gFirstSimSeedCap = text;
  2962. text = response["seconds_since_epoch"].asString();
  2963. if(!text.empty())
  2964. {
  2965. U32 server_utc_time = strtoul(text.c_str(), NULL, 10);
  2966. if(server_utc_time)
  2967. {
  2968. time_t now = time(NULL);
  2969. gUTCOffset = (server_utc_time - now);
  2970. }
  2971. }
  2973. // this is the base used to construct help URLs
  2974. text = response["help_url_format"].asString();
  2975. if (!text.empty())
  2976. {
  2977. // replace the default help URL format
  2978. gSavedSettings.setString("HelpURLFormat",text);
  2980. // don't fall back to Nebraska's pre-connection static help
  2981. gSavedSettings.setBOOL("HelpUseLocal", false);
  2982. }
  2984. std::string home_location = response["home"];
  2985. if(!home_location.empty())
  2986. {
  2987. size_t len = home_location.size();
  2988. LLMemoryStream mstr((U8*)home_location.c_str(), len);
  2989. LLSD sd = LLSDSerialize::fromNotation(mstr, len);
  2990. S32 region_x = sd["region_handle"][0].asInteger();
  2991. S32 region_y = sd["region_handle"][1].asInteger();
  2992. U64 region_handle = to_region_handle(region_x, region_y);
  2993. LLVector3 position = ll_vector3_from_sd(sd["position"]);
  2994. gAgent.setHomePosRegion(region_handle, position);
  2995. }
  2997. gAgent.mMOTD.assign(response["message"]);
  2999. // Options...
  3000. // Each 'option' is an array of submaps. 
  3001. // It appears that we only ever use the first element of the array.
  3002. LLUUID inv_root_folder_id = response["inventory-root"][0]["folder_id"];
  3003. if(inv_root_folder_id.notNull())
  3004. {
  3005. gInventory.setRootFolderID(inv_root_folder_id);
  3006. //gInventory.mock(gAgent.getInventoryRootID());
  3007. }
  3009. LLSD login_flags = response["login-flags"][0];
  3010. if(login_flags.size())
  3011. {
  3012. std::string flag = login_flags["ever_logged_in"];
  3013. if(!flag.empty())
  3014. {
  3015. gAgent.setFirstLogin((flag == "N") ? TRUE : FALSE);
  3016. }
  3018. /*  Flag is currently ignored by the viewer.
  3019. flag = login_flags["stipend_since_login"];
  3020. if(flag == "Y") 
  3021. {
  3022. stipend_since_login = true;
  3023. }
  3024. */
  3026. flag = login_flags["gendered"].asString();
  3027. if(flag == "Y")
  3028. {
  3029. gAgent.setGenderChosen(TRUE);
  3030. }
  3032. bool pacific_daylight_time = false;
  3033. flag = login_flags["daylight_savings"].asString();
  3034. if(flag == "Y")
  3035. {
  3036. pacific_daylight_time = (flag == "Y");
  3037. }
  3039. //setup map of datetime strings to codes and slt & local time offset from utc
  3040. LLStringOps::setupDatetimeInfo(pacific_daylight_time);
  3041. }
  3043. LLSD initial_outfit = response["initial-outfit"][0];
  3044. if(initial_outfit.size())
  3045. {
  3046. std::string flag = initial_outfit["folder_name"];
  3047. if(!flag.empty())
  3048. {
  3049. // Initial outfit is a folder in your inventory,
  3050. // must be an exact folder-name match.
  3051. sInitialOutfit = flag;
  3052. }
  3054. flag = initial_outfit["gender"].asString();
  3055. if(!flag.empty())
  3056. {
  3057. sInitialOutfitGender = flag;
  3058. }
  3059. }
  3061. LLSD global_textures = response["global-textures"][0];
  3062. if(global_textures.size())
  3063. {
  3064. // Extract sun and moon texture IDs.  These are used
  3065. // in the LLVOSky constructor, but I can't figure out
  3066. // how to pass them in.  JC
  3067. LLUUID id = global_textures["sun_texture_id"];
  3068. if(id.notNull())
  3069. {
  3070. gSunTextureID = id;
  3071. }
  3073. id = global_textures["moon_texture_id"];
  3074. if(id.notNull())
  3075. {
  3076. gMoonTextureID = id;
  3077. }
  3079. id = global_textures["cloud_texture_id"];
  3080. if(id.notNull())
  3081. {
  3082. gCloudTextureID = id;
  3083. }
  3084. }
  3087. bool success = false;
  3088. // JC: gesture loading done below, when we have an asset system
  3089. // in place.  Don't delete/clear user_credentials until then.
  3090. if(gAgentID.notNull()
  3091.    && gAgentSessionID.notNull()
  3092.    && gMessageSystem->mOurCircuitCode
  3093.    && gFirstSim.isOk()
  3094.    && gInventory.getRootFolderID().notNull())
  3095. {
  3096. success = true;
  3097. }
  3099. return success;
  3100. }
  3102. void transition_back_to_login_panel(const std::string& emsg)
  3103. {
  3104. if (gNoRender)
  3105. {
  3106. LL_WARNS("AppInit") << "Failed to login!" << LL_ENDL;
  3107. LL_WARNS("AppInit") << emsg << LL_ENDL;
  3108. exit(0);
  3109. }
  3111. // Bounce back to the login screen.
  3112. reset_login(); // calls LLStartUp::setStartupState( STATE_LOGIN_SHOW );
  3113. gSavedSettings.setBOOL("AutoLogin", FALSE);
  3114. }