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

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

游戏引擎

开发平台：

C++ Builder

llappviewer.cpp：源码内容
  1. /** 
  2.  * @file llappviewer.cpp
  3.  * @brief The LLAppViewer class definitions
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llappviewer.h"
  37. // Viewer includes
  38. #include "llversioninfo.h"
  39. #include "llfeaturemanager.h"
  40. #include "lluictrlfactory.h"
  41. #include "lltexteditor.h"
  42. #include "llerrorcontrol.h"
  43. #include "lleventtimer.h"
  44. #include "llviewertexturelist.h"
  45. #include "llgroupmgr.h"
  46. #include "llagent.h"
  47. #include "llagentwearables.h"
  48. #include "llwindow.h"
  49. #include "llviewerstats.h"
  50. #include "llmd5.h"
  51. #include "llpumpio.h"
  52. #include "llmimetypes.h"
  53. #include "llslurl.h"
  54. #include "llstartup.h"
  55. #include "llfocusmgr.h"
  56. #include "llviewerjoystick.h"
  57. #include "llallocator.h"
  58. #include "llares.h" 
  59. #include "llcurl.h"
  60. #include "lltexturestats.h"
  61. #include "lltexturestats.h"
  62. #include "llviewerwindow.h"
  63. #include "llviewerdisplay.h"
  64. #include "llviewermedia.h"
  65. #include "llviewerparcelmedia.h"
  66. #include "llviewermediafocus.h"
  67. #include "llviewermessage.h"
  68. #include "llviewerobjectlist.h"
  69. #include "llworldmap.h"
  70. #include "llmutelist.h"
  71. #include "llviewerhelp.h"
  72. #include "lluicolortable.h"
  73. #include "llurldispatcher.h"
  74. #include "llurlhistory.h"
  75. //#include "llfirstuse.h"
  76. #include "llrender.h"
  77. #include "llteleporthistory.h"
  78. #include "lllocationhistory.h"
  79. #include "llfasttimerview.h"
  80. #include "llvoicechannel.h"
  81. #include "llsidetray.h"
  84. #include "llweb.h"
  85. #include "llsecondlifeurls.h"
  87. // Linden library includes
  88. #include "llimagej2c.h"
  89. #include "llmemory.h"
  90. #include "llprimitive.h"
  91. #include "llurlaction.h"
  92. #include "llvfile.h"
  93. #include "llvfsthread.h"
  94. #include "llvolumemgr.h"
  95. #include "llxfermanager.h"
  97. #include "llnotificationmanager.h"
  98. #include "llnotifications.h"
  99. #include "llnotificationsutil.h"
  101. // Third party library includes
  102. #include <boost/bind.hpp>
  104. #if LL_WINDOWS
  105. #include "llwindebug.h"
  106. # include <share.h> // For _SH_DENYWR in initMarkerFile
  107. #else
  108. #   include <sys/file.h> // For initMarkerFile support
  109. #endif
  111. #include "llapr.h"
  112. #include "apr_dso.h"
  113. #include <boost/lexical_cast.hpp>
  115. #include "llviewerkeyboard.h"
  116. #include "lllfsthread.h"
  117. #include "llworkerthread.h"
  118. #include "lltexturecache.h"
  119. #include "lltexturefetch.h"
  120. #include "llimageworker.h"
  121. #include "llevents.h"
  123. // The files below handle dependencies from cleanup.
  124. #include "llkeyframemotion.h"
  125. #include "llworldmap.h"
  126. #include "llhudmanager.h"
  127. #include "lltoolmgr.h"
  128. #include "llassetstorage.h"
  129. #include "llpolymesh.h"
  130. #include "llcachename.h"
  131. #include "llaudioengine.h"
  132. #include "llstreamingaudio.h"
  133. #include "llviewermenu.h"
  134. #include "llselectmgr.h"
  135. #include "lltrans.h"
  136. #include "lltransutil.h"
  137. #include "lltracker.h"
  138. #include "llviewerparcelmgr.h"
  139. #include "llworldmapview.h"
  140. #include "llpostprocess.h"
  141. #include "llwlparammanager.h"
  142. #include "llwaterparammanager.h"
  144. #include "lldebugview.h"
  145. #include "llconsole.h"
  146. #include "llcontainerview.h"
  147. #include "lltooltip.h"
  149. #include "llsdserialize.h"
  151. #include "llworld.h"
  152. #include "llhudeffecttrail.h"
  153. #include "llvectorperfoptions.h"
  154. #include "llurlsimstring.h"
  155. #include "llwatchdog.h"
  157. // Included so that constants/settings might be initialized
  158. // in save_settings_to_globals()
  159. #include "llbutton.h"
  160. #include "llcombobox.h"
  161. #include "llstatusbar.h"
  162. #include "llsurface.h"
  163. #include "llvosky.h"
  164. #include "llvotree.h"
  165. #include "llvoavatar.h"
  166. #include "llfolderview.h"
  167. #include "llagentpilot.h"
  168. #include "llvovolume.h"
  169. #include "llflexibleobject.h" 
  170. #include "llvosurfacepatch.h"
  171. #include "llviewerfloaterreg.h"
  172. #include "llcommandlineparser.h"
  173. #include "llfloatermemleak.h"
  174. #include "llfloaterreg.h"
  175. #include "llfloatersnapshot.h"
  176. #include "llfloaterinventory.h"
  178. // includes for idle() idleShutdown()
  179. #include "llviewercontrol.h"
  180. #include "lleventnotifier.h"
  181. #include "llcallbacklist.h"
  182. #include "pipeline.h"
  183. #include "llgesturemgr.h"
  184. #include "llsky.h"
  185. #include "llvlmanager.h"
  186. #include "llviewercamera.h"
  187. #include "lldrawpoolbump.h"
  188. #include "llvieweraudio.h"
  189. #include "llimview.h"
  190. #include "llviewerthrottle.h"
  191. #include "llparcel.h"
  192. #include "llavatariconctrl.h"
  194. // *FIX: These extern globals should be cleaned up.
  195. // The globals either represent state/config/resource-storage of either 
  196. // this app, or another 'component' of the viewer. App globals should be 
  197. // moved into the app class, where as the other globals should be 
  198. // moved out of here.
  199. // If a global symbol reference seems valid, it will be included
  200. // via header files above.
  202. //----------------------------------------------------------------------------
  203. // llviewernetwork.h
  204. #include "llviewernetwork.h"
  205. // define a self-registering event API object
  206. #include "llappviewerlistener.h"
  208. #if (LL_LINUX || LL_SOLARIS) && LL_GTK
  209. #include "glib.h"
  210. #endif // (LL_LINUX || LL_SOLARIS) && LL_GTK
  212. #if LL_MSVC
  213. // disable boost::lexical_cast warning
  214. #pragma warning (disable:4702)
  215. #endif
  217. static LLAppViewerListener sAppViewerListener(LLAppViewer::instance);
  219. ////// Windows-specific includes to the bottom - nasty defines in these pollute the preprocessor
  220. //
  221. //----------------------------------------------------------------------------
  222. // viewer.cpp - these are only used in viewer, should be easily moved.
  224. #if LL_DARWIN
  225. extern void init_apple_menu(const char* product);
  226. #endif // LL_DARWIN
  228. extern BOOL gRandomizeFramerate;
  229. extern BOOL gPeriodicSlowFrame;
  230. extern BOOL gDebugGL;
  232. ////////////////////////////////////////////////////////////
  233. // All from the last globals push...
  234. const F32 DEFAULT_AFK_TIMEOUT = 5.f * 60.f; // time with no input before user flagged as Away From Keyboard
  236. F32 gSimLastTime; // Used in LLAppViewer::init and send_stats()
  237. F32 gSimFrames;
  239. BOOL gShowObjectUpdates = FALSE;
  240. BOOL gUseQuickTime = TRUE;
  242. eLastExecEvent gLastExecEvent = LAST_EXEC_NORMAL;
  244. LLSD gDebugInfo;
  246. U32 gFrameCount = 0;
  247. U32 gForegroundFrameCount = 0; // number of frames that app window was in foreground
  248. LLPumpIO* gServicePump = NULL;
  250. U64 gFrameTime = 0;
  251. F32 gFrameTimeSeconds = 0.f;
  252. F32 gFrameIntervalSeconds = 0.f;
  253. F32 gFPSClamped = 10.f; // Pretend we start at target rate.
  254. F32 gFrameDTClamped = 0.f; // Time between adjacent checks to network for packets
  255. U64 gStartTime = 0; // gStartTime is "private", used only to calculate gFrameTimeSeconds
  256. U32 gFrameStalls = 0;
  257. const F64 FRAME_STALL_THRESHOLD = 1.0;
  259. LLTimer gRenderStartTime;
  260. LLFrameTimer gForegroundTime;
  261. LLTimer gLogoutTimer;
  262. static const F32 LOGOUT_REQUEST_TIME = 6.f;  // this will be cut short by the LogoutReply msg.
  263. F32 gLogoutMaxTime = LOGOUT_REQUEST_TIME;
  265. BOOL gDisconnected = FALSE;
  267. // used to restore texture state after a mode switch
  268. LLFrameTimer gRestoreGLTimer;
  269. BOOL gRestoreGL = FALSE;
  270. BOOL gUseWireframe = FALSE;
  272. // VFS globals - see llappviewer.h
  273. LLVFS* gStaticVFS = NULL;
  275. LLMemoryInfo gSysMemory;
  276. U64 gMemoryAllocated = 0; // updated in display_stats() in llviewerdisplay.cpp
  278. std::string gLastVersionChannel;
  280. LLVector3 gWindVec(3.0, 3.0, 0.0);
  281. LLVector3 gRelativeWindVec(0.0, 0.0, 0.0);
  283. U32 gPacketsIn = 0;
  285. BOOL gPrintMessagesThisFrame = FALSE;
  287. BOOL gRandomizeFramerate = FALSE;
  288. BOOL gPeriodicSlowFrame = FALSE;
  290. BOOL gCrashOnStartup = FALSE;
  291. BOOL gLLErrorActivated = FALSE;
  292. BOOL gLogoutInProgress = FALSE;
  294. ////////////////////////////////////////////////////////////
  295. // Internal globals... that should be removed.
  296. static std::string gArgs;
  298. const std::string MARKER_FILE_NAME("SecondLife.exec_marker");
  299. const std::string ERROR_MARKER_FILE_NAME("SecondLife.error_marker");
  300. const std::string LLERROR_MARKER_FILE_NAME("SecondLife.llerror_marker");
  301. const std::string LOGOUT_MARKER_FILE_NAME("SecondLife.logout_marker");
  302. static BOOL gDoDisconnect = FALSE;
  303. static std::string gLaunchFileOnQuit;
  305. // Used on Win32 for other apps to identify our window (eg, win_setup)
  306. const char* const VIEWER_WINDOW_CLASSNAME = "Second Life";
  308. //----------------------------------------------------------------------------
  310. // List of entries from strings.xml to always replace
  311. static std::set<std::string> default_trans_args;
  312. void init_default_trans_args()
  313. {
  314. default_trans_args.insert("SECOND_LIFE"); // World
  315. default_trans_args.insert("APP_NAME");
  316. default_trans_args.insert("CAPITALIZED_APP_NAME");
  317. default_trans_args.insert("SECOND_LIFE_GRID");
  318. default_trans_args.insert("SUPPORT_SITE");
  319. }
  321. //----------------------------------------------------------------------------
  322. // File scope definitons
  323. const char *VFS_DATA_FILE_BASE = "data.db2.x.";
  324. const char *VFS_INDEX_FILE_BASE = "index.db2.x.";
  326. static std::string gWindowTitle;
  328. std::string gLoginPage;
  329. std::vector<std::string> gLoginURIs;
  330. static std::string gHelperURI;
  332. LLAppViewer::LLUpdaterInfo *LLAppViewer::sUpdaterInfo = NULL ;
  334. void idle_afk_check()
  335. {
  336. // check idle timers
  337. if (gSavedSettings.getS32("AFKTimeout") && (gAwayTriggerTimer.getElapsedTimeF32() > gSavedSettings.getS32("AFKTimeout")))
  338. {
  339. gAgent.setAFK();
  340. }
  341. }
  343. // A callback set in LLAppViewer::init()
  344. static void ui_audio_callback(const LLUUID& uuid)
  345. {
  346. if (gAudiop)
  347. {
  348. gAudiop->triggerSound(uuid, gAgent.getID(), 1.0f, LLAudioEngine::AUDIO_TYPE_UI);
  349. }
  350. }
  352. void request_initial_instant_messages()
  353. {
  354. static BOOL requested = FALSE;
  355. if (!requested
  356. && gMessageSystem
  357. && LLMuteList::getInstance()->isLoaded()
  358. && gAgent.getAvatarObject())
  359. {
  360. // Auto-accepted inventory items may require the avatar object
  361. // to build a correct name.  Likewise, inventory offers from
  362. // muted avatars require the mute list to properly mute.
  363. LLMessageSystem* msg = gMessageSystem;
  364. msg->newMessageFast(_PREHASH_RetrieveInstantMessages);
  365. msg->nextBlockFast(_PREHASH_AgentData);
  366. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  367. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  368. gAgent.sendReliableMessage();
  369. requested = TRUE;
  370. }
  371. }
  373. // A settings system callback for CrashSubmitBehavior
  374. bool handleCrashSubmitBehaviorChanged(const LLSD& newvalue)
  375. {
  376. S32 cb = newvalue.asInteger();
  377. const S32 NEVER_SUBMIT_REPORT = 2;
  378. if(cb == NEVER_SUBMIT_REPORT)
  379. {
  380. //  LLWatchdog::getInstance()->cleanup(); // SJB: cleaning up a running watchdog thread is unsafe
  381. LLAppViewer::instance()->destroyMainloopTimeout();
  382. }
  383. else if(gSavedSettings.getBOOL("WatchdogEnabled") == TRUE)
  384. {
  385. // Don't re-enable the watchdog when we change the setting; this may get called before it's started
  386. //  LLWatchdog::getInstance()->init();
  387. }
  388. return true;
  389. }
  391. // Use these strictly for things that are constructed at startup,
  392. // or for things that are performance critical.  JC
  393. static void settings_to_globals()
  394. {
  395. LLBUTTON_H_PAD = gSavedSettings.getS32("ButtonHPad");
  396. BTN_HEIGHT_SMALL = gSavedSettings.getS32("ButtonHeightSmall");
  397. BTN_HEIGHT = gSavedSettings.getS32("ButtonHeight");
  399. MENU_BAR_HEIGHT = gSavedSettings.getS32("MenuBarHeight");
  400. MENU_BAR_WIDTH = gSavedSettings.getS32("MenuBarWidth");
  402. LLCOMBOBOX_HEIGHT = BTN_HEIGHT - 2;
  403. LLCOMBOBOX_WIDTH = 128;
  405. LLSurface::setTextureSize(gSavedSettings.getU32("RegionTextureSize"));
  407. LLImageGL::sGlobalUseAnisotropic = gSavedSettings.getBOOL("RenderAnisotropic");
  408. LLVOVolume::sLODFactor = gSavedSettings.getF32("RenderVolumeLODFactor");
  409. LLVOVolume::sDistanceFactor = 1.f-LLVOVolume::sLODFactor * 0.1f;
  410. LLVolumeImplFlexible::sUpdateFactor = gSavedSettings.getF32("RenderFlexTimeFactor");
  411. LLVOTree::sTreeFactor = gSavedSettings.getF32("RenderTreeLODFactor");
  412. LLVOAvatar::sLODFactor = gSavedSettings.getF32("RenderAvatarLODFactor");
  413. LLVOAvatar::sMaxVisible = gSavedSettings.getS32("RenderAvatarMaxVisible");
  414. LLVOAvatar::sVisibleInFirstPerson = gSavedSettings.getBOOL("FirstPersonAvatarVisible");
  415. // clamp auto-open time to some minimum usable value
  416. LLFolderView::sAutoOpenTime = llmax(0.25f, gSavedSettings.getF32("FolderAutoOpenDelay"));
  417. LLSelectMgr::sRectSelectInclusive = gSavedSettings.getBOOL("RectangleSelectInclusive");
  418. LLSelectMgr::sRenderHiddenSelections = gSavedSettings.getBOOL("RenderHiddenSelections");
  419. LLSelectMgr::sRenderLightRadius = gSavedSettings.getBOOL("RenderLightRadius");
  421. gAgentPilot.mNumRuns = gSavedSettings.getS32("StatsNumRuns");
  422. gAgentPilot.mQuitAfterRuns = gSavedSettings.getBOOL("StatsQuitAfterRuns");
  423. gAgent.setHideGroupTitle(gSavedSettings.getBOOL("RenderHideGroupTitle"));
  425. gDebugWindowProc = gSavedSettings.getBOOL("DebugWindowProc");
  426. gShowObjectUpdates = gSavedSettings.getBOOL("ShowObjectUpdates");
  427. LLWorldMapView::sMapScale = gSavedSettings.getF32("MapScale");
  429. LLCubeMap::sUseCubeMaps = LLFeatureManager::getInstance()->isFeatureAvailable("RenderCubeMap");
  430. }
  432. static void settings_modify()
  433. {
  434. LLRenderTarget::sUseFBO = gSavedSettings.getBOOL("RenderUseFBO");
  435. LLVOAvatar::sUseImpostors = gSavedSettings.getBOOL("RenderUseImpostors");
  436. LLVOSurfacePatch::sLODFactor = gSavedSettings.getF32("RenderTerrainLODFactor");
  437. LLVOSurfacePatch::sLODFactor *= LLVOSurfacePatch::sLODFactor; //square lod factor to get exponential range of [1,4]
  438. gDebugGL = gSavedSettings.getBOOL("RenderDebugGL") || gDebugSession;
  439. gDebugPipeline = gSavedSettings.getBOOL("RenderDebugPipeline");
  440. gAuditTexture = gSavedSettings.getBOOL("AuditTexture");
  441. #if LL_VECTORIZE
  442. if (gSysCPU.hasAltivec())
  443. {
  444. gSavedSettings.setBOOL("VectorizeEnable", TRUE );
  445. gSavedSettings.setU32("VectorizeProcessor", 0 );
  446. }
  447. else
  448. if (gSysCPU.hasSSE2())
  449. {
  450. gSavedSettings.setBOOL("VectorizeEnable", TRUE );
  451. gSavedSettings.setU32("VectorizeProcessor", 2 );
  452. }
  453. else
  454. if (gSysCPU.hasSSE())
  455. {
  456. gSavedSettings.setBOOL("VectorizeEnable", TRUE );
  457. gSavedSettings.setU32("VectorizeProcessor", 1 );
  458. }
  459. else
  460. {
  461. // Don't bother testing or running if CPU doesn't support it. JC
  462. gSavedSettings.setBOOL("VectorizePerfTest", FALSE );
  463. gSavedSettings.setBOOL("VectorizeEnable", FALSE );
  464. gSavedSettings.setU32("VectorizeProcessor", 0 );
  465. gSavedSettings.setBOOL("VectorizeSkin", FALSE);
  466. }
  467. #else
  468. // This build target doesn't support SSE, don't test/run.
  469. gSavedSettings.setBOOL("VectorizePerfTest", FALSE );
  470. gSavedSettings.setBOOL("VectorizeEnable", FALSE );
  471. gSavedSettings.setU32("VectorizeProcessor", 0 );
  472. gSavedSettings.setBOOL("VectorizeSkin", FALSE);
  473. #endif
  474. }
  476. class LLFastTimerLogThread : public LLThread
  477. {
  478. public:
  479. std::string mFile;
  481. LLFastTimerLogThread() : LLThread("fast timer log")
  482. {
  483. if(LLFastTimer::sLog)
  484. {
  485. mFile = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance.slp");
  486. }
  487. if(LLFastTimer::sMetricLog)
  488. {
  489. mFile = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "metric.slp");
  490. }
  491. }
  493. void run()
  494. {
  495. std::ofstream os(mFile.c_str());
  497. while (!LLAppViewer::instance()->isQuitting())
  498. {
  499. LLFastTimer::writeLog(os);
  500. os.flush();
  501. ms_sleep(32);
  502. }
  504. os.close();
  505. }
  506. };
  508. void LLAppViewer::initGridChoice()
  509. {
  510. // Load up the initial grid choice from:
  511. // - hard coded defaults...
  512. // - command line settings...
  513. // - if dev build, persisted settings...
  515. // Set the "grid choice", this is specified by command line.
  516. std::string grid_choice = gSavedSettings.getString("CmdLineGridChoice");
  517. LLViewerLogin::getInstance()->setGridChoice(grid_choice);
  519. // Load last server choice by default 
  520. // ignored if the command line grid choice has been set
  521. if(grid_choice.empty())
  522. {
  523. S32 server = gSavedSettings.getS32("ServerChoice");
  524. server = llclamp(server, 0, (S32)GRID_INFO_COUNT - 1);
  525. if(server == GRID_INFO_OTHER)
  526. {
  527. std::string custom_server = gSavedSettings.getString("CustomServer");
  528. LLViewerLogin::getInstance()->setGridChoice(custom_server);
  529. }
  530. else if(server != (S32)GRID_INFO_NONE)
  531. {
  532. LLViewerLogin::getInstance()->setGridChoice((EGridInfo)server);
  533. }
  534. }
  535. }
  537. //virtual
  538. bool LLAppViewer::initSLURLHandler()
  539. {
  540. // does nothing unless subclassed
  541. return false;
  542. }
  544. //virtual
  545. bool LLAppViewer::sendURLToOtherInstance(const std::string& url)
  546. {
  547. // does nothing unless subclassed
  548. return false;
  549. }
  551. //----------------------------------------------------------------------------
  552. // LLAppViewer definition
  554. // Static members.
  555. // The single viewer app.
  556. LLAppViewer* LLAppViewer::sInstance = NULL;
  558. const std::string LLAppViewer::sGlobalSettingsName = "Global"; 
  560. LLTextureCache* LLAppViewer::sTextureCache = NULL; 
  561. LLImageDecodeThread* LLAppViewer::sImageDecodeThread = NULL; 
  562. LLTextureFetch* LLAppViewer::sTextureFetch = NULL; 
  564. LLAppViewer::LLAppViewer() : 
  565. mMarkerFile(),
  566. mLogoutMarkerFile(NULL),
  567. mReportedCrash(false),
  568. mNumSessions(0),
  569. mPurgeCache(false),
  570. mPurgeOnExit(false),
  571. mSecondInstance(false),
  572. mSavedFinalSnapshot(false),
  573. mForceGraphicsDetail(false),
  574. mQuitRequested(false),
  575. mLogoutRequestSent(false),
  576. mYieldTime(-1),
  577. mMainloopTimeout(NULL),
  578. mAgentRegionLastAlive(false),
  579. mRandomizeFramerate(LLCachedControl<bool>(gSavedSettings,"Randomize Framerate", FALSE)),
  580. mPeriodicSlowFrame(LLCachedControl<bool>(gSavedSettings,"Periodic Slow Frame", FALSE)),
  581. mFastTimerLogThread(NULL)
  582. {
  583. if(NULL != sInstance)
  584. {
  585. llerrs << "Oh no! An instance of LLAppViewer already exists! LLAppViewer is sort of like a singleton." << llendl;
  586. }
  588. setupErrorHandling();
  589. sInstance = this;
  590. }
  592. LLAppViewer::~LLAppViewer()
  593. {
  594. destroyMainloopTimeout();
  596. // If we got to this destructor somehow, the app didn't hang.
  597. removeMarkerFile();
  598. }
  600. bool LLAppViewer::init()
  601. {
  602. //
  603. // Start of the application
  604. //
  605. // IMPORTANT! Do NOT put anything that will write
  606. // into the log files during normal startup until AFTER
  607. // we run the "program crashed last time" error handler below.
  608. //
  609. LLFastTimer::reset();
  611. // Need to do this initialization before we do anything else, since anything
  612. // that touches files should really go through the lldir API
  613. gDirUtilp->initAppDirs("SecondLife");
  614. // set skin search path to default, will be overridden later
  615. // this allows simple skinned file lookups to work
  616. gDirUtilp->setSkinFolder("default");
  618. initLogging();
  620. //
  621. // OK to write stuff to logs now, we've now crash reported if necessary
  622. //
  624. init_default_trans_args();
  626. if (!initConfiguration())
  627. return false;
  629. // Although initLogging() is the right place to mess with
  630. // setFatalFunction(), we can't query gSavedSettings until after
  631. // initConfiguration().
  632. S32 rc(gSavedSettings.getS32("QAModeTermCode"));
  633. if (rc >= 0)
  634. {
  635. // QAModeTermCode set, terminate with that rc on LL_ERRS. Use _exit()
  636. // rather than exit() because normal cleanup depends too much on
  637. // successful startup!
  638. LLError::setFatalFunction(boost::bind(_exit, rc));
  639. }
  641.     mAlloc.setProfilingEnabled(gSavedSettings.getBOOL("MemProfiling"));
  643.     // *NOTE:Mani - LLCurl::initClass is not thread safe. 
  644.     // Called before threads are created.
  645.     LLCurl::initClass();
  647.     initThreads();
  649.     writeSystemInfo();
  651. // Build a string representing the current version number.
  652.     gCurrentVersion = llformat("%s %s", 
  653.    gSavedSettings.getString("VersionChannelName").c_str(),
  654.    LLVersionInfo::getVersion().c_str());
  656. //////////////////////////////////////////////////////////////////////////////
  657. //////////////////////////////////////////////////////////////////////////////
  658. //////////////////////////////////////////////////////////////////////////////
  659. //////////////////////////////////////////////////////////////////////////////
  660. // *FIX: The following code isn't grouped into functions yet.
  662. // Statistics / debug timer initialization
  663. init_statistics();
  665. //
  666. // Various introspection concerning the libs we're using - particularly
  667.         // the libs involved in getting to a full login screen.
  668. //
  669. LL_INFOS("InitInfo") << "J2C Engine is: " << LLImageJ2C::getEngineInfo() << LL_ENDL;
  670. LL_INFOS("InitInfo") << "libcurl version is: " << LLCurl::getVersionString() << LL_ENDL;
  672. // Get the single value from the crash settings file, if it exists
  673. std::string crash_settings_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, CRASH_SETTINGS_FILE);
  674. gCrashSettings.loadFromFile(crash_settings_filename);
  675. if(gSavedSettings.getBOOL("IgnoreAllNotifications"))
  676. {
  677. gCrashSettings.setS32(CRASH_BEHAVIOR_SETTING, CRASH_BEHAVIOR_ALWAYS_SEND);
  678. gCrashSettings.saveToFile(crash_settings_filename, FALSE);
  679. }
  681. /////////////////////////////////////////////////
  682. // OS-specific login dialogs
  683. /////////////////////////////////////////////////
  685. //test_cached_control();
  687. // track number of times that app has run
  688. mNumSessions = gSavedSettings.getS32("NumSessions");
  689. mNumSessions++;
  690. gSavedSettings.setS32("NumSessions", mNumSessions);
  692. if (gSavedSettings.getBOOL("VerboseLogs"))
  693. {
  694. LLError::setPrintLocation(true);
  695. }
  697. // Widget construction depends on LLUI being initialized
  698. LLUI::settings_map_t settings_map;
  699. settings_map["config"] = &gSavedSettings;
  700. settings_map["ignores"] = &gWarningSettings;
  701. settings_map["floater"] = &gSavedSettings; // *TODO: New settings file
  702. settings_map["account"] = &gSavedPerAccountSettings;
  704. LLUI::initClass(settings_map,
  705. LLUIImageList::getInstance(),
  706. ui_audio_callback,
  707. &LLUI::sGLScaleFactor);
  709. // Setup paths and LLTrans after LLUI::initClass has been called
  710. LLUI::setupPaths();
  711. LLTransUtil::parseStrings("strings.xml", default_trans_args);
  712. LLTransUtil::parseLanguageStrings("language_settings.xml");
  714. // LLKeyboard relies on LLUI to know what some accelerator keys are called.
  715. LLKeyboard::setStringTranslatorFunc( LLTrans::getKeyboardString );
  717. LLWeb::initClass();   // do this after LLUI
  719. // Provide the text fields with callbacks for opening Urls
  720. LLUrlAction::setOpenURLCallback(&LLWeb::loadURL);
  721. LLUrlAction::setOpenURLInternalCallback(&LLWeb::loadURLInternal);
  722. LLUrlAction::setOpenURLExternalCallback(&LLWeb::loadURLExternal);
  723. LLUrlAction::setExecuteSLURLCallback(&LLURLDispatcher::dispatchFromTextEditor);
  725. // Let code in llui access the viewer help floater
  726. LLUI::sHelpImpl = LLViewerHelp::getInstance();
  728. // Load translations for tooltips
  729. LLFloater::initClass();
  731. /////////////////////////////////////////////////
  733. LLToolMgr::getInstance(); // Initialize tool manager if not already instantiated
  735. LLViewerFloaterReg::registerFloaters();
  737. /////////////////////////////////////////////////
  738. //
  739. // Load settings files
  740. //
  741. //
  742. LLGroupMgr::parseRoleActions("role_actions.xml");
  744. LLAgent::parseTeleportMessages("teleport_strings.xml");
  746. LLViewerJointMesh::updateVectorize();
  748. // load MIME type -> media impl mappings
  749. std::string mime_types_name;
  750. #if LL_DARWIN
  751. mime_types_name = "mime_types_mac.xml";
  752. #elif LL_LINUX
  753. mime_types_name = "mime_types_linux.xml";
  754. #else
  755. mime_types_name = "mime_types.xml";
  756. #endif
  757. LLMIMETypes::parseMIMETypes( mime_types_name ); 
  759. // Copy settings to globals. *TODO: Remove or move to appropriage class initializers
  760. settings_to_globals();
  761. // Setup settings listeners
  762. settings_setup_listeners();
  763. // Modify settings based on system configuration and compile options
  764. settings_modify();
  766. // Find partition serial number (Windows) or hardware serial (Mac)
  767. mSerialNumber = generateSerialNumber();
  769. // do any necessary set-up for accepting incoming SLURLs from apps
  770. initSLURLHandler();
  772. if(false == initHardwareTest())
  773. {
  774. // Early out from user choice.
  775. return false;
  776. }
  778. // Always fetch the Ethernet MAC address, needed both for login
  779. // and password load.
  780. LLUUID::getNodeID(gMACAddress);
  782. // Prepare for out-of-memory situations, during which we will crash on
  783. // purpose and save a dump.
  784. #if LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP
  785. MemSetErrorHandler(first_mem_error_handler);
  786. #endif // LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP
  788. // *Note: this is where gViewerStats used to be created.
  790. //
  791. // Initialize the VFS, and gracefully handle initialization errors
  792. //
  794. if (!initCache())
  795. {
  796. std::ostringstream msg;
  797. msg << LLTrans::getString("MBUnableToAccessFile");
  798. OSMessageBox(msg.str(),LLStringUtil::null,OSMB_OK);
  799. return 1;
  800. }
  802. //
  803. // Initialize the window
  804. //
  805. gGLActive = TRUE;
  806. initWindow();
  808. // call all self-registered classes
  809. LLInitClassList::instance().fireCallbacks();
  811. LLFolderViewItem::initClass(); // SJB: Needs to happen after initWindow(), not sure why but related to fonts
  813. gGLManager.getGLInfo(gDebugInfo);
  814. gGLManager.printGLInfoString();
  816. //load key settings
  817. bind_keyboard_functions();
  819. // Load Default bindings
  820. if (!gViewerKeyboard.loadBindings(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"keys.ini")))
  821. {
  822. LL_ERRS("InitInfo") << "Unable to open keys.ini" << LL_ENDL;
  823. }
  824. // Load Custom bindings (override defaults)
  825. gViewerKeyboard.loadBindings(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"custom_keys.ini"));
  827. // If we don't have the right GL requirements, exit.
  828. if (!gGLManager.mHasRequirements && !gNoRender)
  829. {
  830. // can't use an alert here since we're exiting and
  831. // all hell breaks lose.
  832. OSMessageBox(
  833. LLNotifications::instance().getGlobalString("UnsupportedGLRequirements"),
  834. LLStringUtil::null,
  835. OSMB_OK);
  836. return 0;
  837. }
  839. // alert the user if they are using unsupported hardware
  840. if(!gSavedSettings.getBOOL("AlertedUnsupportedHardware"))
  841. {
  842. bool unsupported = false;
  843. LLSD args;
  844. std::string minSpecs;
  846. // get cpu data from xml
  847. std::stringstream minCPUString(LLNotifications::instance().getGlobalString("UnsupportedCPUAmount"));
  848. S32 minCPU = 0;
  849. minCPUString >> minCPU;
  851. // get RAM data from XML
  852. std::stringstream minRAMString(LLNotifications::instance().getGlobalString("UnsupportedRAMAmount"));
  853. U64 minRAM = 0;
  854. minRAMString >> minRAM;
  855. minRAM = minRAM * 1024 * 1024;
  857. if(!LLFeatureManager::getInstance()->isGPUSupported() && LLFeatureManager::getInstance()->getGPUClass() != GPU_CLASS_UNKNOWN)
  858. {
  859. minSpecs += LLNotifications::instance().getGlobalString("UnsupportedGPU");
  860. minSpecs += "n";
  861. unsupported = true;
  862. }
  863. if(gSysCPU.getMhz() < minCPU)
  864. {
  865. minSpecs += LLNotifications::instance().getGlobalString("UnsupportedCPU");
  866. minSpecs += "n";
  867. unsupported = true;
  868. }
  869. if(gSysMemory.getPhysicalMemoryClamped() < minRAM)
  870. {
  871. minSpecs += LLNotifications::instance().getGlobalString("UnsupportedRAM");
  872. minSpecs += "n";
  873. unsupported = true;
  874. }
  876. if (LLFeatureManager::getInstance()->getGPUClass() == GPU_CLASS_UNKNOWN)
  877. {
  878. LLNotificationsUtil::add("UnknownGPU");
  879. } 
  881. if(unsupported)
  882. {
  883. if(!gSavedSettings.controlExists("WarnUnsupportedHardware") 
  884. || gSavedSettings.getBOOL("WarnUnsupportedHardware"))
  885. {
  886. args["MINSPECS"] = minSpecs;
  887. LLNotificationsUtil::add("UnsupportedHardware", args );
  888. }
  890. }
  891. }
  893. // save the graphics card
  894. gDebugInfo["GraphicsCard"] = LLFeatureManager::getInstance()->getGPUString();
  896. // Save the current version to the prefs file
  897. gSavedSettings.setString("LastRunVersion", gCurrentVersion);
  899. gSimLastTime = gRenderStartTime.getElapsedTimeF32();
  900. gSimFrames = (F32)gFrameCount;
  902. LLViewerJoystick::getInstance()->init(false);
  903. gGLActive = FALSE;
  904. if (gSavedSettings.getBOOL("QAMode") && gSavedSettings.getS32("QAModeEventHostPort") > 0)
  905. {
  906. loadEventHostModule(gSavedSettings.getS32("QAModeEventHostPort"));
  907. }
  909. LLViewerMedia::initClass();
  911. return true;
  912. }
  914. static LLFastTimer::DeclareTimer FTM_MESSAGES("System Messages");
  915. static LLFastTimer::DeclareTimer FTM_SLEEP("Sleep");
  916. static LLFastTimer::DeclareTimer FTM_TEXTURE_CACHE("Texture Cache");
  917. static LLFastTimer::DeclareTimer FTM_DECODE("Image Decode");
  918. static LLFastTimer::DeclareTimer FTM_VFS("VFS Thread");
  919. static LLFastTimer::DeclareTimer FTM_LFS("LFS Thread");
  920. static LLFastTimer::DeclareTimer FTM_PAUSE_THREADS("Pause Threads");
  921. static LLFastTimer::DeclareTimer FTM_IDLE("Idle");
  922. static LLFastTimer::DeclareTimer FTM_PUMP("Pump");
  924. bool LLAppViewer::mainLoop()
  925. {
  926. LLMemType mt1(LLMemType::MTYPE_MAIN);
  927. mMainloopTimeout = new LLWatchdogTimeout();
  929. //-------------------------------------------
  930. // Run main loop until time to quit
  931. //-------------------------------------------
  933. // Create IO Pump to use for HTTP Requests.
  934. gServicePump = new LLPumpIO(gAPRPoolp);
  935. LLHTTPClient::setPump(*gServicePump);
  936. LLCurl::setCAFile(gDirUtilp->getCAFile());
  937. LLCurl::setSSLVerify(! gSavedSettings.getBOOL("NoVerifySSLCert"));
  939. // Note: this is where gLocalSpeakerMgr and gActiveSpeakerMgr used to be instantiated.
  941. LLVoiceChannel::initClass();
  942. LLVoiceClient::init(gServicePump);
  944. LLTimer frameTimer,idleTimer;
  945. LLTimer debugTime;
  946. LLViewerJoystick* joystick(LLViewerJoystick::getInstance());
  947. joystick->setNeedsReset(true);
  949.     LLEventPump& mainloop(LLEventPumps::instance().obtain("mainloop"));
  950.     // As we do not (yet) send data on the mainloop LLEventPump that varies
  951.     // with each frame, no need to instantiate a new LLSD event object each
  952.     // time. Obviously, if that changes, just instantiate the LLSD at the
  953.     // point of posting.
  954.     LLSD newFrame;
  956. // Handle messages
  957. while (!LLApp::isExiting())
  958. {
  959. LLFastTimer::nextFrame(); // Should be outside of any timer instances
  961. try
  962. {
  963. pingMainloopTimeout("Main:MiscNativeWindowEvents");
  965. if (gViewerWindow)
  966. {
  967. LLFastTimer t2(FTM_MESSAGES);
  968. gViewerWindow->mWindow->processMiscNativeEvents();
  969. }
  971. pingMainloopTimeout("Main:GatherInput");
  973. if (gViewerWindow)
  974. {
  975. LLFastTimer t2(FTM_MESSAGES);
  976. if (!restoreErrorTrap())
  977. {
  978. llwarns << " Someone took over my signal/exception handler (post messagehandling)!" << llendl;
  979. }
  981. gViewerWindow->mWindow->gatherInput();
  982. }
  984. #if 1 && !LL_RELEASE_FOR_DOWNLOAD
  985. // once per second debug info
  986. if (debugTime.getElapsedTimeF32() > 1.f)
  987. {
  988. debugTime.reset();
  989. }
  991. #endif
  992. //memory leaking simulation
  993. LLFloaterMemLeak* mem_leak_instance =
  994. LLFloaterReg::findTypedInstance<LLFloaterMemLeak>("mem_leaking");
  995. if(mem_leak_instance)
  996. {
  997. mem_leak_instance->idle() ;
  998. }
  1000.             // canonical per-frame event
  1001.             mainloop.post(newFrame);
  1003. if (!LLApp::isExiting())
  1004. {
  1005. pingMainloopTimeout("Main:JoystickKeyboard");
  1007. // Scan keyboard for movement keys.  Command keys and typing
  1008. // are handled by windows callbacks.  Don't do this until we're
  1009. // done initializing.  JC
  1010. if (gViewerWindow->mWindow->getVisible() 
  1011. && gViewerWindow->getActive()
  1012. && !gViewerWindow->mWindow->getMinimized()
  1013. && LLStartUp::getStartupState() == STATE_STARTED
  1014. && !gViewerWindow->getShowProgress()
  1015. && !gFocusMgr.focusLocked())
  1016. {
  1017. LLMemType mjk(LLMemType::MTYPE_JOY_KEY);
  1018. joystick->scanJoystick();
  1019. gKeyboard->scanKeyboard();
  1020. }
  1022. // Update state based on messages, user input, object idle.
  1023. {
  1024. pauseMainloopTimeout(); // *TODO: Remove. Messages shouldn't be stalling for 20+ seconds!
  1026. LLFastTimer t3(FTM_IDLE);
  1027. idle();
  1029. if (gAres != NULL && gAres->isInitialized())
  1030. {
  1031. LLMemType mt_ip(LLMemType::MTYPE_IDLE_PUMP);
  1032. pingMainloopTimeout("Main:ServicePump");
  1033. LLFastTimer t4(FTM_PUMP);
  1034. gAres->process();
  1035. // this pump is necessary to make the login screen show up
  1036. gServicePump->pump();
  1037. gServicePump->callback();
  1038. }
  1040. resumeMainloopTimeout();
  1041. }
  1042.  
  1043. if (gDoDisconnect && (LLStartUp::getStartupState() == STATE_STARTED))
  1044. {
  1045. pauseMainloopTimeout();
  1046. saveFinalSnapshot();
  1047. disconnectViewer();
  1048. resumeMainloopTimeout();
  1049. }
  1051. // Render scene.
  1052. if (!LLApp::isExiting())
  1053. {
  1054. pingMainloopTimeout("Main:Display");
  1055. gGLActive = TRUE;
  1056. display();
  1057. pingMainloopTimeout("Main:Snapshot");
  1058. LLFloaterSnapshot::update(); // take snapshots
  1059. gGLActive = FALSE;
  1060. }
  1062. }
  1064. pingMainloopTimeout("Main:Sleep");
  1066. pauseMainloopTimeout();
  1068. // Sleep and run background threads
  1069. {
  1070. LLMemType mt_sleep(LLMemType::MTYPE_SLEEP);
  1071. LLFastTimer t2(FTM_SLEEP);
  1072. bool run_multiple_threads = gSavedSettings.getBOOL("RunMultipleThreads");
  1074. // yield some time to the os based on command line option
  1075. if(mYieldTime >= 0)
  1076. {
  1077. ms_sleep(mYieldTime);
  1078. }
  1080. // yield cooperatively when not running as foreground window
  1081. if (   gNoRender
  1082.    || (gViewerWindow && !gViewerWindow->mWindow->getVisible())
  1083. || !gFocusMgr.getAppHasFocus())
  1084. {
  1085. // Sleep if we're not rendering, or the window is minimized.
  1086. S32 milliseconds_to_sleep = llclamp(gSavedSettings.getS32("BackgroundYieldTime"), 0, 1000);
  1087. // don't sleep when BackgroundYieldTime set to 0, since this will still yield to other threads
  1088. // of equal priority on Windows
  1089. if (milliseconds_to_sleep > 0)
  1090. {
  1091. ms_sleep(milliseconds_to_sleep);
  1092. // also pause worker threads during this wait period
  1093. LLAppViewer::getTextureCache()->pause();
  1094. LLAppViewer::getImageDecodeThread()->pause();
  1095. }
  1096. }
  1098. if (mRandomizeFramerate)
  1099. {
  1100. ms_sleep(rand() % 200);
  1101. }
  1103. if (mPeriodicSlowFrame
  1104. && (gFrameCount % 10 == 0))
  1105. {
  1106. llinfos << "Periodic slow frame - sleeping 500 ms" << llendl;
  1107. ms_sleep(500);
  1108. }
  1111. const F64 min_frame_time = 0.0; //(.0333 - .0010); // max video frame rate = 30 fps
  1112. const F64 min_idle_time = 0.0; //(.0010); // min idle time = 1 ms
  1113. const F64 max_idle_time = run_multiple_threads ? min_idle_time : llmin(.005*10.0*gFrameTimeSeconds, 0.005); // 5 ms a second
  1114. idleTimer.reset();
  1115. while(1)
  1116. {
  1117. S32 work_pending = 0;
  1118. S32 io_pending = 0;
  1119. {
  1120. LLFastTimer ftm(FTM_TEXTURE_CACHE);
  1121.   work_pending += LLAppViewer::getTextureCache()->update(1); // unpauses the texture cache thread
  1122. }
  1123. {
  1124. LLFastTimer ftm(FTM_DECODE);
  1125.   work_pending += LLAppViewer::getImageDecodeThread()->update(1); // unpauses the image thread
  1126. }
  1127. {
  1128. LLFastTimer ftm(FTM_DECODE);
  1129.   work_pending += LLAppViewer::getTextureFetch()->update(1); // unpauses the texture fetch thread
  1130. }
  1132. {
  1133. LLFastTimer ftm(FTM_VFS);
  1134.   io_pending += LLVFSThread::updateClass(1);
  1135. }
  1136. {
  1137. LLFastTimer ftm(FTM_LFS);
  1138.   io_pending += LLLFSThread::updateClass(1);
  1139. }
  1141. if (io_pending > 1000)
  1142. {
  1143. ms_sleep(llmin(io_pending/100,100)); // give the vfs some time to catch up
  1144. }
  1146. F64 frame_time = frameTimer.getElapsedTimeF64();
  1147. F64 idle_time = idleTimer.getElapsedTimeF64();
  1148. if (frame_time >= min_frame_time &&
  1149. idle_time >= min_idle_time &&
  1150. (!work_pending || idle_time >= max_idle_time))
  1151. {
  1152. break;
  1153. }
  1154. }
  1155. if ((LLStartUp::getStartupState() >= STATE_CLEANUP) &&
  1156. (frameTimer.getElapsedTimeF64() > FRAME_STALL_THRESHOLD))
  1157. {
  1158. gFrameStalls++;
  1159. }
  1160. frameTimer.reset();
  1162.  // Prevent the worker threads from running while rendering.
  1163. // if (LLThread::processorCount()==1) //pause() should only be required when on a single processor client...
  1164. if (run_multiple_threads == FALSE)
  1165. {
  1166. LLFastTimer ftm(FTM_PAUSE_THREADS);
  1167.  
  1168. LLAppViewer::getTextureCache()->pause();
  1169. LLAppViewer::getImageDecodeThread()->pause();
  1170. // LLAppViewer::getTextureFetch()->pause(); // Don't pause the fetch (IO) thread
  1171. }
  1172. //LLVFSThread::sLocal->pause(); // Prevent the VFS thread from running while rendering.
  1173. //LLLFSThread::sLocal->pause(); // Prevent the LFS thread from running while rendering.
  1175. resumeMainloopTimeout();
  1177. pingMainloopTimeout("Main:End");
  1178. }
  1180. }
  1181. catch(std::bad_alloc)
  1182. {
  1183. //stop memory leaking simulation
  1184. LLFloaterMemLeak* mem_leak_instance =
  1185. LLFloaterReg::findTypedInstance<LLFloaterMemLeak>("mem_leaking");
  1186. if(mem_leak_instance)
  1187. {
  1188. mem_leak_instance->stop() ;
  1189. llwarns << "Bad memory allocation in LLAppViewer::mainLoop()!" << llendl ;
  1190. }
  1191. else
  1192. {
  1193. //output possible call stacks to log file.
  1194. LLError::LLCallStacks::print() ;
  1196. llerrs << "Bad memory allocation in LLAppViewer::mainLoop()!" << llendl ;
  1197. }
  1198. }
  1199. }
  1201. // Save snapshot for next time, if we made it through initialization
  1202. if (STATE_STARTED == LLStartUp::getStartupState())
  1203. {
  1204. try
  1205. {
  1206. saveFinalSnapshot();
  1207. }
  1208. catch(std::bad_alloc)
  1209. {
  1210. llwarns << "Bad memory allocation when saveFinalSnapshot() is called!" << llendl ;
  1212. //stop memory leaking simulation
  1213. LLFloaterMemLeak* mem_leak_instance =
  1214. LLFloaterReg::findTypedInstance<LLFloaterMemLeak>("mem_leaking");
  1215. if(mem_leak_instance)
  1216. {
  1217. mem_leak_instance->stop() ;
  1218. }
  1219. }
  1220. }
  1222. delete gServicePump;
  1224. destroyMainloopTimeout();
  1226. llinfos << "Exiting main_loop" << llendflush;
  1228. return true;
  1229. }
  1231. bool LLAppViewer::cleanup()
  1232. {
  1233. // workaround for DEV-35406 crash on shutdown
  1234. LLEventPumps::instance().reset();
  1236. // *TODO - generalize this and move DSO wrangling to a helper class -brad
  1237. std::set<struct apr_dso_handle_t *>::const_iterator i;
  1238. for(i = mPlugins.begin(); i != mPlugins.end(); ++i)
  1239. {
  1240. int (*ll_plugin_stop_func)(void) = NULL;
  1241. apr_status_t rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll_plugin_stop_func, *i, "ll_plugin_stop");
  1242. ll_plugin_stop_func();
  1244. rv = apr_dso_unload(*i);
  1245. }
  1246. mPlugins.clear();
  1248. //----------------------------------------------
  1249. //this test code will be removed after the test
  1250. //test manual call stack tracer
  1251. if(gSavedSettings.getBOOL("QAMode"))
  1252. {
  1253. LLError::LLCallStacks::print() ;
  1254. }
  1255. //end of the test code
  1256. //----------------------------------------------
  1258. //flag all elements as needing to be destroyed immediately
  1259. // to ensure shutdown order
  1260. LLMortician::setZealous(TRUE);
  1262. LLVoiceClient::terminate();
  1264. disconnectViewer();
  1266. llinfos << "Viewer disconnected" << llendflush;
  1268. display_cleanup(); 
  1270. release_start_screen(); // just in case
  1272. LLError::logToFixedBuffer(NULL);
  1274. llinfos << "Cleaning Up" << llendflush;
  1276. // Must clean up texture references before viewer window is destroyed.
  1277. LLHUDManager::getInstance()->updateEffects();
  1278. LLHUDObject::updateAll();
  1279. LLHUDManager::getInstance()->cleanupEffects();
  1280. LLHUDObject::cleanupHUDObjects();
  1281. llinfos << "HUD Objects cleaned up" << llendflush;
  1283. LLKeyframeDataCache::clear();
  1285.   // End TransferManager before deleting systems it depends on (Audio, VFS, AssetStorage)
  1286. #if 0 // this seems to get us stuck in an infinite loop...
  1287. gTransferManager.cleanup();
  1288. #endif
  1290. // Note: this is where gWorldMap used to be deleted.
  1292. // Note: this is where gHUDManager used to be deleted.
  1293. LLHUDManager::getInstance()->shutdownClass();
  1296. delete gAssetStorage;
  1297. gAssetStorage = NULL;
  1299. LLPolyMesh::freeAllMeshes();
  1301. delete gCacheName;
  1302. gCacheName = NULL;
  1304. // Note: this is where gLocalSpeakerMgr and gActiveSpeakerMgr used to be deleted.
  1306. LLWorldMap::getInstance()->reset(); // release any images
  1308. llinfos << "Global stuff deleted" << llendflush;
  1310. if (gAudiop)
  1311. {
  1312. // shut down the streaming audio sub-subsystem first, in case it relies on not outliving the general audio subsystem.
  1314. LLStreamingAudioInterface *sai = gAudiop->getStreamingAudioImpl();
  1315. delete sai;
  1316. gAudiop->setStreamingAudioImpl(NULL);
  1318. // shut down the audio subsystem
  1320. bool want_longname = false;
  1321. if (gAudiop->getDriverName(want_longname) == "FMOD")
  1322. {
  1323. // This hack exists because fmod likes to occasionally
  1324. // crash or hang forever when shutting down, for no
  1325. // apparent reason.
  1326. llwarns << "Hack, skipping FMOD audio engine cleanup" << llendflush;
  1327. }
  1328. else
  1329. {
  1330. gAudiop->shutdown();
  1331. }
  1333. delete gAudiop;
  1334. gAudiop = NULL;
  1335. }
  1337. // Note: this is where LLFeatureManager::getInstance()-> used to be deleted.
  1339. // Patch up settings for next time
  1340. // Must do this before we delete the viewer window,
  1341. // such that we can suck rectangle information out of
  1342. // it.
  1343. cleanupSavedSettings();
  1344. llinfos << "Settings patched up" << llendflush;
  1346. // delete some of the files left around in the cache.
  1347. removeCacheFiles("*.wav");
  1348. removeCacheFiles("*.tmp");
  1349. removeCacheFiles("*.lso");
  1350. removeCacheFiles("*.out");
  1351. removeCacheFiles("*.dsf");
  1352. removeCacheFiles("*.bodypart");
  1353. removeCacheFiles("*.clothing");
  1355. llinfos << "Cache files removed" << llendflush;
  1357. // Wait for any pending VFS IO
  1358. while (1)
  1359. {
  1360. S32 pending = LLVFSThread::updateClass(0);
  1361. pending += LLLFSThread::updateClass(0);
  1362. if (!pending)
  1363. {
  1364. break;
  1365. }
  1366. llinfos << "Waiting for pending IO to finish: " << pending << llendflush;
  1367. ms_sleep(100);
  1368. }
  1369. llinfos << "Shutting down Views" << llendflush;
  1371. // Destroy the UI
  1372. if( gViewerWindow)
  1373. gViewerWindow->shutdownViews();
  1375. llinfos << "Cleaning up Inventory" << llendflush;
  1377. // Cleanup Inventory after the UI since it will delete any remaining observers
  1378. // (Deleted observers should have already removed themselves)
  1379. gInventory.cleanupInventory();
  1381. llinfos << "Cleaning up Selections" << llendflush;
  1383. // Clean up selection managers after UI is destroyed, as UI may be observing them.
  1384. // Clean up before GL is shut down because we might be holding on to objects with texture references
  1385. LLSelectMgr::cleanupGlobals();
  1387. llinfos << "Shutting down OpenGL" << llendflush;
  1389. // Shut down OpenGL
  1390. if( gViewerWindow)
  1391. {
  1392. gViewerWindow->shutdownGL();
  1394. // Destroy window, and make sure we're not fullscreen
  1395. // This may generate window reshape and activation events.
  1396. // Therefore must do this before destroying the message system.
  1397. delete gViewerWindow;
  1398. gViewerWindow = NULL;
  1399. llinfos << "ViewerWindow deleted" << llendflush;
  1400. }
  1402. llinfos << "Cleaning up Keyboard & Joystick" << llendflush;
  1404. // viewer UI relies on keyboard so keep it aound until viewer UI isa gone
  1405. delete gKeyboard;
  1406. gKeyboard = NULL;
  1408. // Turn off Space Navigator and similar devices
  1409. LLViewerJoystick::getInstance()->terminate();
  1411. llinfos << "Cleaning up Objects" << llendflush;
  1413. LLViewerObject::cleanupVOClasses();
  1415. LLWaterParamManager::cleanupClass();
  1416. LLWLParamManager::cleanupClass();
  1417. LLPostProcess::cleanupClass();
  1419. LLTracker::cleanupInstance();
  1421. // *FIX: This is handled in LLAppViewerWin32::cleanup().
  1422. // I'm keeping the comment to remember its order in cleanup,
  1423. // in case of unforseen dependency.
  1424. //#if LL_WINDOWS
  1425. // gDXHardware.cleanup();
  1426. //#endif // LL_WINDOWS
  1428. LLVolumeMgr* volume_manager = LLPrimitive::getVolumeManager();
  1429. if (!volume_manager->cleanup())
  1430. {
  1431. llwarns << "Remaining references in the volume manager!" << llendflush;
  1432. }
  1433. LLPrimitive::cleanupVolumeManager();
  1435. llinfos << "Additional Cleanup..." << llendflush;
  1437. LLViewerParcelMgr::cleanupGlobals();
  1439. // *Note: this is where gViewerStats used to be deleted.
  1441.   //end_messaging_system();
  1443. LLFollowCamMgr::cleanupClass();
  1444. //LLVolumeMgr::cleanupClass();
  1445. LLPrimitive::cleanupVolumeManager();
  1446. LLWorldMapView::cleanupClass();
  1447. LLFolderViewItem::cleanupClass();
  1448. LLUI::cleanupClass();
  1450. //
  1451. // Shut down the VFS's AFTER the decode manager cleans up (since it cleans up vfiles).
  1452. // Also after viewerwindow is deleted, since it may have image pointers (which have vfiles)
  1453. // Also after shutting down the messaging system since it has VFS dependencies
  1455. //
  1456. llinfos << "Cleaning up VFS" << llendflush;
  1457. LLVFile::cleanupClass();
  1459. llinfos << "Saving Data" << llendflush;
  1461. // Quitting with "Remember Password" turned off should always stomp your
  1462. // saved password, whether or not you successfully logged in.  JC
  1463. if (!gSavedSettings.getBOOL("RememberPassword"))
  1464. {
  1465. LLStartUp::deletePasswordFromDisk();
  1466. }
  1468. // Store the time of our current logoff
  1469. gSavedPerAccountSettings.setU32("LastLogoff", time_corrected());
  1471. // Must do this after all panels have been deleted because panels that have persistent rects
  1472. // save their rects on delete.
  1473. gSavedSettings.saveToFile(gSavedSettings.getString("ClientSettingsFile"), TRUE);
  1475. LLUIColorTable::instance().saveUserSettings();
  1477. // PerAccountSettingsFile should be empty if no user has been logged on.
  1478. // *FIX:Mani This should get really saved in a "logoff" mode. 
  1479. if (gSavedSettings.getString("PerAccountSettingsFile").empty())
  1480. {
  1481. llinfos << "Not saving per-account settings; don't know the account name yet." << llendl;
  1482. }
  1483. else
  1484. {
  1485. gSavedPerAccountSettings.saveToFile(gSavedSettings.getString("PerAccountSettingsFile"), TRUE);
  1486. llinfos << "Saved settings" << llendflush;
  1487. }
  1489. std::string crash_settings_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, CRASH_SETTINGS_FILE);
  1490. // save all settings, even if equals defaults
  1491. gCrashSettings.saveToFile(crash_settings_filename, FALSE);
  1493. std::string warnings_settings_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, getSettingsFilename("Default", "Warnings"));
  1494. gWarningSettings.saveToFile(warnings_settings_filename, TRUE);
  1496. // Save URL history file
  1497. LLURLHistory::saveFile("url_history.xml");
  1499. // save mute list. gMuteList used to also be deleted here too.
  1500. LLMuteList::getInstance()->cache(gAgent.getID());
  1502. if (mPurgeOnExit)
  1503. {
  1504. llinfos << "Purging all cache files on exit" << llendflush;
  1505. std::string mask = gDirUtilp->getDirDelimiter() + "*.*";
  1506. gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,""),mask);
  1507. }
  1509. removeMarkerFile(); // Any crashes from here on we'll just have to ignore
  1511. writeDebugInfo();
  1513. LLLocationHistory::getInstance()->save();
  1515. LLAvatarIconIDCache::getInstance()->save();
  1517. llinfos << "Shutting down Threads" << llendflush;
  1519. // Let threads finish
  1520. LLTimer idleTimer;
  1521. idleTimer.reset();
  1522. const F64 max_idle_time = 5.f; // 5 seconds
  1523. while(1)
  1524. {
  1525. S32 pending = 0;
  1526. pending += LLAppViewer::getTextureCache()->update(1); // unpauses the worker thread
  1527. pending += LLAppViewer::getImageDecodeThread()->update(1); // unpauses the image thread
  1528. pending += LLAppViewer::getTextureFetch()->update(1); // unpauses the texture fetch thread
  1529. pending += LLVFSThread::updateClass(0);
  1530. pending += LLLFSThread::updateClass(0);
  1531. F64 idle_time = idleTimer.getElapsedTimeF64();
  1532. if (!pending || idle_time >= max_idle_time)
  1533. {
  1534. llwarns << "Quitting with pending background tasks." << llendl;
  1535. break;
  1536. }
  1537. }
  1539. // Delete workers first
  1540. // shotdown all worker threads before deleting them in case of co-dependencies
  1541. sTextureCache->shutdown();
  1542. sTextureFetch->shutdown();
  1543. sImageDecodeThread->shutdown();
  1545. delete sTextureCache;
  1546.     sTextureCache = NULL;
  1547. delete sTextureFetch;
  1548.     sTextureFetch = NULL;
  1549. delete sImageDecodeThread;
  1550.     sImageDecodeThread = NULL;
  1551. delete mFastTimerLogThread;
  1552. mFastTimerLogThread = NULL;
  1554. if (LLFastTimerView::sAnalyzePerformance)
  1555. {
  1556. llinfos << "Analyzing performance" << llendl;
  1558. if(LLFastTimer::sLog)
  1559. {
  1560. LLFastTimerView::doAnalysis(
  1561. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance_baseline.slp"),
  1562. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance.slp"),
  1563. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "performance_report.csv"));
  1564. }
  1565. if(LLFastTimer::sMetricLog)
  1566. {
  1567. LLFastTimerView::doAnalysis(
  1568. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "metric_baseline.slp"),
  1569. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "metric.slp"),
  1570. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "metric_report.csv"));
  1571. }
  1572. }
  1573. LLMetricPerformanceTester::cleanClass() ;
  1575. llinfos << "Cleaning up Media and Textures" << llendflush;
  1577. //Note:
  1578. //LLViewerMedia::cleanupClass() has to be put before gTextureList.shutdown()
  1579. //because some new image might be generated during cleaning up media. --bao
  1580. LLViewerMedia::cleanupClass();
  1581. LLViewerParcelMedia::cleanupClass();
  1582. gTextureList.shutdown(); // shutdown again in case a callback added something
  1583. LLUIImageList::getInstance()->cleanUp();
  1585. // This should eventually be done in LLAppViewer
  1586. LLImage::cleanupClass();
  1587. LLVFSThread::cleanupClass();
  1588. LLLFSThread::cleanupClass();
  1590. #ifndef LL_RELEASE_FOR_DOWNLOAD
  1591. llinfos << "Auditing VFS" << llendl;
  1592. gVFS->audit();
  1593. #endif
  1595. llinfos << "Misc Cleanup" << llendflush;
  1597. // For safety, the LLVFS has to be deleted *after* LLVFSThread. This should be cleaned up.
  1598. // (LLVFS doesn't know about LLVFSThread so can't kill pending requests) -Steve
  1599. delete gStaticVFS;
  1600. gStaticVFS = NULL;
  1601. delete gVFS;
  1602. gVFS = NULL;
  1604. gSavedSettings.cleanup();
  1605. LLUIColorTable::instance().clear();
  1606. gCrashSettings.cleanup();
  1608. LLWatchdog::getInstance()->cleanup();
  1610. llinfos << "Shutting down message system" << llendflush;
  1611. end_messaging_system();
  1613. // *NOTE:Mani - The following call is not thread safe. 
  1614. LLCurl::cleanupClass();
  1616. // If we're exiting to launch an URL, do that here so the screen
  1617. // is at the right resolution before we launch IE.
  1618. if (!gLaunchFileOnQuit.empty())
  1619. {
  1620. llinfos << "Launch file on quit." << llendflush;
  1621. #if LL_WINDOWS
  1622. // Indicate an application is starting.
  1623. SetCursor(LoadCursor(NULL, IDC_WAIT));
  1624. #endif
  1626. // HACK: Attempt to wait until the screen res. switch is complete.
  1627. ms_sleep(1000);
  1629. LLWeb::loadURLExternal( gLaunchFileOnQuit );
  1630. llinfos << "File launched." << llendflush;
  1631. }
  1633. ll_close_fail_log();
  1635.     llinfos << "Goodbye!" << llendflush;
  1637. // return 0;
  1638. return true;
  1639. }
  1641. // A callback for llerrs to call during the watchdog error.
  1642. void watchdog_llerrs_callback(const std::string &error_string)
  1643. {
  1644. gLLErrorActivated = true;
  1646. #ifdef LL_WINDOWS
  1647. RaiseException(0,0,0,0);
  1648. #else
  1649. raise(SIGQUIT);
  1650. #endif
  1651. }
  1653. // A callback for the watchdog to call.
  1654. void watchdog_killer_callback()
  1655. {
  1656. LLError::setFatalFunction(watchdog_llerrs_callback);
  1657. llerrs << "Watchdog killer event" << llendl;
  1658. }
  1660. bool LLAppViewer::initThreads()
  1661. {
  1662. #if MEM_TRACK_MEM
  1663. static const bool enable_threads = false;
  1664. #else
  1665. static const bool enable_threads = true;
  1666. #endif
  1668. const S32 NEVER_SUBMIT_REPORT = 2;
  1669. bool use_watchdog = gSavedSettings.getBOOL("WatchdogEnabled");
  1670. bool send_reports = gCrashSettings.getS32(CRASH_BEHAVIOR_SETTING) != NEVER_SUBMIT_REPORT;
  1671. if(use_watchdog && send_reports)
  1672. {
  1673. LLWatchdog::getInstance()->init(watchdog_killer_callback);
  1674. }
  1676. LLVFSThread::initClass(enable_threads && false);
  1677. LLLFSThread::initClass(enable_threads && false);
  1679. // Image decoding
  1680. LLAppViewer::sImageDecodeThread = new LLImageDecodeThread(enable_threads && true);
  1681. LLAppViewer::sTextureCache = new LLTextureCache(enable_threads && true);
  1682. LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), sImageDecodeThread, enable_threads && true);
  1683. LLImage::initClass();
  1685. if (LLFastTimer::sLog || LLFastTimer::sMetricLog)
  1686. {
  1687. LLFastTimer::sLogLock = new LLMutex(NULL);
  1688. mFastTimerLogThread = new LLFastTimerLogThread();
  1689. mFastTimerLogThread->start();
  1690. }
  1692. // *FIX: no error handling here!
  1693. return true;
  1694. }
  1696. void errorCallback(const std::string &error_string)
  1697. {
  1698. #ifndef LL_RELEASE_FOR_DOWNLOAD
  1699. OSMessageBox(error_string, LLTrans::getString("MBFatalError"), OSMB_OK);
  1700. #endif
  1702. //Set the ErrorActivated global so we know to create a marker file
  1703. gLLErrorActivated = true;
  1705. LLError::crashAndLoop(error_string);
  1706. }
  1708. bool LLAppViewer::initLogging()
  1709. {
  1710. //
  1711. // Set up logging defaults for the viewer
  1712. //
  1713. LLError::initForApplication(
  1714. gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
  1715. LLError::setFatalFunction(errorCallback);
  1717. // Remove the last ".old" log file.
  1718. std::string old_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
  1719.      "SecondLife.old");
  1720. LLFile::remove(old_log_file);
  1722. // Rename current log file to ".old"
  1723. std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
  1724.      "SecondLife.log");
  1725. LLFile::rename(log_file, old_log_file);
  1727. // Set the log file to SecondLife.log
  1729. LLError::logToFile(log_file);
  1731. // *FIX:Mani no error handling here!
  1732. return true;
  1733. }
  1735. bool LLAppViewer::loadSettingsFromDirectory(const std::string& location_key,
  1736.     bool set_defaults)
  1737. {
  1738. // Find and vet the location key.
  1739. if(!mSettingsLocationList.has(location_key))
  1740. {
  1741. llerrs << "Requested unknown location: " << location_key << llendl;
  1742. return false;
  1743. }
  1745. LLSD location = mSettingsLocationList.get(location_key);
  1747. if(!location.has("PathIndex"))
  1748. {
  1749. llerrs << "Settings location is missing PathIndex value. Settings cannot be loaded." << llendl;
  1750. return false;
  1751. }
  1752. ELLPath path_index = (ELLPath)(location.get("PathIndex").asInteger());
  1753. if(path_index <= LL_PATH_NONE || path_index >= LL_PATH_LAST)
  1754. {
  1755. llerrs << "Out of range path index in app_settings/settings_files.xml" << llendl;
  1756. return false;
  1757. }
  1759. // Iterate through the locations list of files.
  1760. LLSD files = location.get("Files");
  1761. for(LLSD::map_iterator itr = files.beginMap(); itr != files.endMap(); ++itr)
  1762. {
  1763. std::string settings_group = (*itr).first;
  1764. llinfos << "Attempting to load settings for the group " << settings_group 
  1765.     << " - from location " << location_key << llendl;
  1767. if(!LLControlGroup::getInstance(settings_group))
  1768. {
  1769. llwarns << "No matching settings group for name " << settings_group << llendl;
  1770. continue;
  1771. }
  1773. LLSD file = (*itr).second;
  1775. std::string full_settings_path;
  1776. if(file.has("NameFromSetting"))
  1777. {
  1778. std::string custom_name_setting = file.get("NameFromSetting");
  1779. // *NOTE: Regardless of the group currently being lodaed,
  1780. // this setting is always read from the Global settings.
  1781. if(LLControlGroup::getInstance(sGlobalSettingsName)->controlExists(custom_name_setting))
  1782. {
  1783. std::string file_name = 
  1784. LLControlGroup::getInstance(sGlobalSettingsName)->getString(custom_name_setting);
  1785. full_settings_path = file_name;
  1786. }
  1787. }
  1789. if(full_settings_path.empty())
  1790. {
  1791. std::string file_name = file.get("Name");
  1792. full_settings_path = gDirUtilp->getExpandedFilename(path_index, file_name);
  1793. }
  1795. int requirement = 0;
  1796. if(file.has("Requirement"))
  1797. {
  1798. requirement = file.get("Requirement").asInteger();
  1799. }
  1801. if(!LLControlGroup::getInstance(settings_group)->loadFromFile(full_settings_path, set_defaults))
  1802. {
  1803. if(requirement == 1)
  1804. {
  1805. llwarns << "Error: Cannot load required settings file from: " 
  1806. << full_settings_path << llendl;
  1807. return false;
  1808. }
  1809. else
  1810. {
  1811. llwarns << "Cannot load " << full_settings_path << " - No settings found." << llendl;
  1812. }
  1813. }
  1814. else
  1815. {
  1816. llinfos << "Loaded settings file " << full_settings_path << llendl;
  1817. }
  1818. }
  1820. return true;
  1821. }
  1823. std::string LLAppViewer::getSettingsFilename(const std::string& location_key,
  1824.  const std::string& file)
  1825. {
  1826. if(mSettingsLocationList.has(location_key))
  1827. {
  1828. LLSD location = mSettingsLocationList.get(location_key);
  1829. if(location.has("Files"))
  1830. {
  1831. LLSD files = location.get("Files");
  1832. if(files.has(file) && files[file].has("Name"))
  1833. {
  1834. return files.get(file).get("Name").asString();
  1835. }
  1836. }
  1837. }
  1838. return std::string();
  1839. }
  1841. void LLAppViewer::loadColorSettings()
  1842. {
  1843. LLUIColorTable::instance().loadFromSettings();
  1844. }
  1846. bool LLAppViewer::initConfiguration()
  1847. {
  1848. //Load settings files list
  1849. std::string settings_file_list = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "settings_files.xml");
  1850. LLControlGroup settings_control("SettingsFiles");
  1851. llinfos << "Loading settings file list " << settings_file_list << llendl;
  1852. if (0 == settings_control.loadFromFile(settings_file_list))
  1853. {
  1854.         llerrs << "Cannot load default configuration file " << settings_file_list << llendl;
  1855. }
  1857. mSettingsLocationList = settings_control.getLLSD("Locations");
  1859. // The settings and command line parsing have a fragile
  1860. // order-of-operation:
  1861. // - load defaults from app_settings
  1862. // - set procedural settings values
  1863. // - read command line settings
  1864. // - selectively apply settings needed to load user settings.
  1865.     // - load overrides from user_settings 
  1866. // - apply command line settings (to override the overrides)
  1867. // - load per account settings (happens in llstartup
  1869. // - load defaults
  1870. bool set_defaults = true;
  1871. if(!loadSettingsFromDirectory("Default", set_defaults))
  1872. {
  1873. std::ostringstream msg;
  1874. msg << "Unable to load default settings file. The installation may be corrupted.";
  1875. OSMessageBox(msg.str(),LLStringUtil::null,OSMB_OK);
  1876. return false;
  1877. }
  1879. LLUI::setupPaths(); // setup paths for LLTrans based on settings files only
  1880. LLTransUtil::parseStrings("strings.xml", default_trans_args);
  1881. LLTransUtil::parseLanguageStrings("language_settings.xml");
  1882. // - set procedural settings
  1883. // Note: can't use LL_PATH_PER_SL_ACCOUNT for any of these since we haven't logged in yet
  1884. gSavedSettings.setString("ClientSettingsFile", 
  1885.         gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, getSettingsFilename("Default", "Global")));
  1887. gSavedSettings.setString("VersionChannelName", LLVersionInfo::getChannel());
  1889. #ifndef LL_RELEASE_FOR_DOWNLOAD
  1890. // provide developer build only overrides for these control variables that are not
  1891. // persisted to settings.xml
  1892. LLControlVariable* c = gSavedSettings.getControl("ShowConsoleWindow");
  1893. if (c)
  1894. {
  1895. c->setValue(true, false);
  1896. }
  1897. c = gSavedSettings.getControl("AllowMultipleViewers");
  1898. if (c)
  1899. {
  1900. c->setValue(true, false);
  1901. }
  1902. #endif
  1904. //*FIX:Mani - Set default to disabling watchdog mainloop 
  1905. // timeout for mac and linux. There is no call stack info 
  1906. // on these platform to help debug.
  1907. #ifndef LL_RELEASE_FOR_DOWNLOAD
  1908. gSavedSettings.setBOOL("WatchdogEnabled", FALSE);
  1909. gSavedSettings.setBOOL("QAMode", TRUE );
  1910. #endif
  1912. #ifndef LL_WINDOWS
  1913. gSavedSettings.setBOOL("WatchdogEnabled", FALSE);
  1914. #endif
  1916. gCrashSettings.getControl(CRASH_BEHAVIOR_SETTING)->getSignal()->connect(boost::bind(&handleCrashSubmitBehaviorChanged, _2));
  1918. // These are warnings that appear on the first experience of that condition.
  1919. // They are already set in the settings_default.xml file, but still need to be added to LLFirstUse
  1920. // for disable/reset ability
  1921. // LLFirstUse::addConfigVariable("FirstBalanceIncrease");
  1922. // LLFirstUse::addConfigVariable("FirstBalanceDecrease");
  1923. // LLFirstUse::addConfigVariable("FirstSit");
  1924. // LLFirstUse::addConfigVariable("FirstMap");
  1925. // LLFirstUse::addConfigVariable("FirstGoTo");
  1926. // LLFirstUse::addConfigVariable("FirstBuild");
  1927. // LLFirstUse::addConfigVariable("FirstLeftClickNoHit");
  1928. // LLFirstUse::addConfigVariable("FirstTeleport");
  1929. // LLFirstUse::addConfigVariable("FirstOverrideKeys");
  1930. // LLFirstUse::addConfigVariable("FirstAttach");
  1931. // LLFirstUse::addConfigVariable("FirstAppearance");
  1932. // LLFirstUse::addConfigVariable("FirstInventory");
  1933. // LLFirstUse::addConfigVariable("FirstSandbox");
  1934. // LLFirstUse::addConfigVariable("FirstFlexible");
  1935. // LLFirstUse::addConfigVariable("FirstDebugMenus");
  1936. // LLFirstUse::addConfigVariable("FirstSculptedPrim");
  1937. // LLFirstUse::addConfigVariable("FirstVoice");
  1938. // LLFirstUse::addConfigVariable("FirstMedia");
  1940. // - read command line settings.
  1941. LLControlGroupCLP clp;
  1942. std::string cmd_line_config = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,
  1943.   "cmd_line.xml");
  1945. clp.configure(cmd_line_config, &gSavedSettings);
  1947. if(!initParseCommandLine(clp))
  1948. {
  1949. llwarns << "Error parsing command line options. Command Line options ignored."  << llendl;
  1951. llinfos << "Command line usage:n" << clp << llendl;
  1953. std::ostringstream msg;
  1954. msg << LLTrans::getString("MBCmdLineError") << clp.getErrorMessage();
  1955. OSMessageBox(msg.str(),LLStringUtil::null,OSMB_OK);
  1956. return false;
  1957. }
  1959. // - selectively apply settings 
  1961. // If the user has specified a alternate settings file name.
  1962. // Load it now before loading the user_settings/settings.xml
  1963. if(clp.hasOption("settings"))
  1964. {
  1965. std::string user_settings_filename = 
  1966. gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, 
  1967.    clp.getOption("settings")[0]);
  1968. gSavedSettings.setString("ClientSettingsFile", user_settings_filename);
  1969. llinfos << "Using command line specified settings filename: " 
  1970. << user_settings_filename << llendl;
  1971. }
  1973. // - load overrides from user_settings 
  1974. loadSettingsFromDirectory("User");
  1975. // - apply command line settings 
  1976. clp.notify(); 
  1978. // Handle initialization from settings.
  1979. // Start up the debugging console before handling other options.
  1980. if (gSavedSettings.getBOOL("ShowConsoleWindow"))
  1981. {
  1982. initConsole();
  1983. }
  1985. if(clp.hasOption("help"))
  1986. {
  1987. std::ostringstream msg;
  1988. msg << LLTrans::getString("MBCmdLineUsg") << "n" << clp;
  1989. llinfos << msg.str() << llendl;
  1991. OSMessageBox(
  1992. msg.str().c_str(),
  1993. LLStringUtil::null,
  1994. OSMB_OK);
  1996. return false;
  1997. }
  1999.     if(clp.hasOption("set"))
  2000.     {
  2001.         const LLCommandLineParser::token_vector_t& set_values = clp.getOption("set");
  2002.         if(0x1 & set_values.size())
  2003.         {
  2004.             llwarns << "Invalid '--set' parameter count." << llendl;
  2005.         }
  2006.         else
  2007.         {
  2008.             LLCommandLineParser::token_vector_t::const_iterator itr = set_values.begin();
  2009.             for(; itr != set_values.end(); ++itr)
  2010.             {
  2011.                 const std::string& name = *itr;
  2012.                 const std::string& value = *(++itr);
  2013. LLControlVariable* c = LLControlGroup::getInstance(sGlobalSettingsName)->getControl(name);
  2014.                 if(c)
  2015.                 {
  2016.                     c->setValue(value, false);
  2017.                 }
  2018.                 else
  2019.                 {
  2020.                     llwarns << "'--set' specified with unknown setting: '"
  2021.                         << name << "'." << llendl;
  2022.                 }
  2023.             }
  2024.         }
  2025.     }
  2027.     initGridChoice();
  2029. // If we have specified crash on startup, set the global so we'll trigger the crash at the right time
  2030. if(clp.hasOption("crashonstartup"))
  2031. {
  2032. gCrashOnStartup = TRUE;
  2033. }
  2035. if (clp.hasOption("logperformance"))
  2036. {
  2037. LLFastTimer::sLog = TRUE;
  2038. }
  2040. if(clp.hasOption("logmetrics"))
  2041. {
  2042. LLFastTimer::sMetricLog = TRUE ;
  2043. }
  2045. if (clp.hasOption("graphicslevel"))
  2046. {
  2047. const LLCommandLineParser::token_vector_t& value = clp.getOption("graphicslevel");
  2048.         if(value.size() != 1)
  2049.         {
  2050. llwarns << "Usage: -graphicslevel <0-3>" << llendl;
  2051.         }
  2052.         else
  2053.         {
  2054. std::string detail = value.front();
  2055. mForceGraphicsDetail = TRUE;
  2057. switch (detail.c_str()[0])
  2058. {
  2059. case '0': 
  2060. gSavedSettings.setU32("RenderQualityPerformance", 0);
  2061. break;
  2062. case '1': 
  2063. gSavedSettings.setU32("RenderQualityPerformance", 1);
  2064. break;
  2065. case '2': 
  2066. gSavedSettings.setU32("RenderQualityPerformance", 2);
  2067. break;
  2068. case '3': 
  2069. gSavedSettings.setU32("RenderQualityPerformance", 3);
  2070. break;
  2071. default:
  2072. mForceGraphicsDetail = FALSE;
  2073. llwarns << "Usage: -graphicslevel <0-3>" << llendl;
  2074. break;
  2075. }
  2076.         }
  2077. }
  2079. if (clp.hasOption("analyzeperformance"))
  2080. {
  2081. LLFastTimerView::sAnalyzePerformance = TRUE;
  2082. }
  2084. if (clp.hasOption("replaysession"))
  2085. {
  2086. LLAgentPilot::sReplaySession = TRUE;
  2087. }
  2089. if (clp.hasOption("nonotifications"))
  2090. {
  2091. gSavedSettings.setBOOL("IgnoreAllNotifications", TRUE);
  2092. }
  2094. if (clp.hasOption("debugsession"))
  2095. {
  2096. gDebugSession = TRUE;
  2097. gDebugGL = TRUE;
  2099. ll_init_fail_log(gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "test_failures.log"));
  2100. }
  2102. // Handle slurl use. NOTE: Don't let SL-55321 reappear.
  2104.     // *FIX: This init code should be made more robust to prevent 
  2105.     // the issue SL-55321 from returning. One thought is to allow 
  2106.     // only select options to be set from command line when a slurl 
  2107.     // is specified. More work on the settings system is needed to 
  2108.     // achieve this. For now...
  2110.     // *NOTE:Mani The command line parser parses tokens and is 
  2111.     // setup to bail after parsing the '--url' option or the 
  2112.     // first option specified without a '--option' flag (or
  2113.     // any other option that uses the 'last_option' setting - 
  2114.     // see LLControlGroupCLP::configure())
  2116.     // What can happen is that someone can use IE (or potentially 
  2117.     // other browsers) and do the rough equivalent of command 
  2118.     // injection and steal passwords. Phoenix. SL-55321
  2119.     if(clp.hasOption("url"))
  2120.     {
  2121.         std::string slurl = clp.getOption("url")[0];
  2122.         if (LLSLURL::isSLURLCommand(slurl))
  2123.         {
  2124.         LLStartUp::sSLURLCommand = slurl;
  2125.         }
  2126.         else
  2127.         {
  2128.         LLURLSimString::setString(slurl);
  2129.         }
  2130.     }
  2131.     else if(clp.hasOption("slurl"))
  2132.     {
  2133.         std::string slurl = clp.getOption("slurl")[0];
  2134.         if(LLSLURL::isSLURL(slurl))
  2135.         {
  2136.             if (LLSLURL::isSLURLCommand(slurl))
  2137.             {
  2138.             LLStartUp::sSLURLCommand = slurl;
  2139.             }
  2140.             else
  2141.             {
  2142.             LLURLSimString::setString(slurl);
  2143.             }
  2144.         }
  2145.     }
  2147.     const LLControlVariable* skinfolder = gSavedSettings.getControl("SkinCurrent");
  2148.     if(skinfolder && LLStringUtil::null != skinfolder->getValue().asString())
  2149.     {   
  2150. // hack to force the skin to default.
  2151.         //gDirUtilp->setSkinFolder(skinfolder->getValue().asString());
  2152. gDirUtilp->setSkinFolder("default");
  2153.     }
  2155.     mYieldTime = gSavedSettings.getS32("YieldTime");
  2157. // Read skin/branding settings if specified.
  2158. //if (! gDirUtilp->getSkinDir().empty() )
  2159. //{
  2160. // std::string skin_def_file = gDirUtilp->findSkinnedFilename("skin.xml");
  2161. // LLXmlTree skin_def_tree;
  2163. // if (!skin_def_tree.parseFile(skin_def_file))
  2164. // {
  2165. // llerrs << "Failed to parse skin definition." << llendl;
  2166. // }
  2168. //}
  2170. #if LL_DARWIN
  2171. // Initialize apple menubar and various callbacks
  2172. init_apple_menu(LLTrans::getString("APP_NAME").c_str());
  2174. #if __ppc__
  2175. // If the CPU doesn't have Altivec (i.e. it's not at least a G4), don't go any further.
  2176. // Only test PowerPC - all Intel Macs have SSE.
  2177. if(!gSysCPU.hasAltivec())
  2178. {
  2179. std::ostringstream msg;
  2180. msg << LLTrans::getString("MBRequiresAltiVec");
  2181. OSMessageBox(
  2182. msg.str(),
  2183. LLStringUtil::null,
  2184. OSMB_OK);
  2185. removeMarkerFile();
  2186. return false;
  2187. }
  2188. #endif
  2190. #endif // LL_DARWIN
  2192. // Display splash screen.  Must be after above check for previous
  2193. // crash as this dialog is always frontmost.
  2194. std::ostringstream splash_msg;
  2195. splash_msg << "Loading " << LLTrans::getString("SECOND_LIFE") << "...";
  2196. LLSplashScreen::show();
  2197. LLSplashScreen::update(splash_msg.str());
  2199. //LLVolumeMgr::initClass();
  2200. LLVolumeMgr* volume_manager = new LLVolumeMgr();
  2201. volume_manager->useMutex(); // LLApp and LLMutex magic must be manually enabled
  2202. LLPrimitive::setVolumeManager(volume_manager);
  2204. // Note: this is where we used to initialize gFeatureManagerp.
  2206. gStartTime = totalTime();
  2208. //
  2209. // Set the name of the window
  2210. //
  2211. gWindowTitle = LLTrans::getString("APP_NAME");
  2212. #if LL_DEBUG
  2213. gWindowTitle += std::string(" [DEBUG] ") + gArgs;
  2214. #else
  2215. gWindowTitle += std::string(" ") + gArgs;
  2216. #endif
  2217. LLStringUtil::truncate(gWindowTitle, 255);
  2219. //RN: if we received a URL, hand it off to the existing instance.
  2220. // don't call anotherInstanceRunning() when doing URL handoff, as
  2221. // it relies on checking a marker file which will not work when running
  2222. // out of different directories
  2223. std::string slurl;
  2224. if (!LLStartUp::sSLURLCommand.empty())
  2225. {
  2226. slurl = LLStartUp::sSLURLCommand;
  2227. }
  2228. else if (LLURLSimString::parse())
  2229. {
  2230. slurl = LLURLSimString::getURL();
  2231. }
  2232. if (!slurl.empty())
  2233. {
  2234. if (sendURLToOtherInstance(slurl))
  2235. {
  2236. // successfully handed off URL to existing instance, exit
  2237. return false;
  2238. }
  2239. }
  2241. if (!gSavedSettings.getBOOL("AllowMultipleViewers"))
  2242. {
  2243.     //
  2244.     // Check for another instance of the app running
  2245.     //
  2247. mSecondInstance = anotherInstanceRunning();
  2249. if (mSecondInstance)
  2250. {
  2251. std::ostringstream msg;
  2252. msg << LLTrans::getString("MBAlreadyRunning");
  2253. OSMessageBox(
  2254. msg.str(),
  2255. LLStringUtil::null,
  2256. OSMB_OK);
  2257. return false;
  2258. }
  2260. initMarkerFile();
  2261.         
  2262.         checkForCrash();
  2263.     }
  2264. else
  2265. {
  2266. mSecondInstance = anotherInstanceRunning();
  2268. if (mSecondInstance)
  2269. {
  2270. // This is the second instance of SL. Turn off voice support,
  2271. // but make sure the setting is *not* persisted.
  2272. LLControlVariable* disable_voice = gSavedSettings.getControl("CmdLineDisableVoice");
  2273. if(disable_voice)
  2274. {
  2275. const BOOL DO_NOT_PERSIST = FALSE;
  2276. disable_voice->setValue(LLSD(TRUE), DO_NOT_PERSIST);
  2277. }
  2278. }
  2280. initMarkerFile();
  2281.         
  2282.         if(!mSecondInstance)
  2283.         {
  2284.             checkForCrash();
  2285.         }
  2286. }
  2288.     // need to do this here - need to have initialized global settings first
  2289. std::string nextLoginLocation = gSavedSettings.getString( "NextLoginLocation" );
  2290. if ( nextLoginLocation.length() )
  2291. {
  2292. LLURLSimString::setString( nextLoginLocation );
  2293. };
  2295. gLastRunVersion = gSavedSettings.getString("LastRunVersion");
  2297. loadColorSettings();
  2299. return true; // Config was successful.
  2300. }
  2303. void LLAppViewer::checkForCrash(void)
  2304. {
  2305.     
  2306. #if LL_SEND_CRASH_REPORTS
  2307. //*NOTE:Mani The current state of the crash handler has the MacOSX
  2308. // sending all crash reports as freezes, in order to let 
  2309. // the MacOSX CrashRepoter generate stacks before spawning the 
  2310. // SL crash logger.
  2311. // The Linux and Windows clients generate their own stacks and
  2312. // spawn the SL crash logger immediately. This may change in the future. 
  2313. #if LL_DARWIN
  2314. if(gLastExecEvent != LAST_EXEC_NORMAL)
  2315. #else
  2316. if (gLastExecEvent == LAST_EXEC_FROZE)
  2317. #endif
  2318.     {
  2319.         llinfos << "Last execution froze, requesting to send crash report." << llendl;
  2320.         //
  2321.         // Pop up a freeze or crash warning dialog
  2322.         //
  2323.         S32 choice;
  2324.         if(gCrashSettings.getS32(CRASH_BEHAVIOR_SETTING) == CRASH_BEHAVIOR_ASK)
  2325.         {
  2326.             std::ostringstream msg;
  2327. msg << LLTrans::getString("MBFrozenCrashed");
  2328. std::string alert = LLTrans::getString("APP_NAME") + " " + LLTrans::getString("MBAlert");
  2329.             choice = OSMessageBox(msg.str(),
  2330.                                   alert,
  2331.                                   OSMB_YESNO);
  2332.         } 
  2333.         else if(gCrashSettings.getS32(CRASH_BEHAVIOR_SETTING) == CRASH_BEHAVIOR_NEVER_SEND)
  2334.         {
  2335.             choice = OSBTN_NO;
  2336.         }
  2337.         else
  2338.         {
  2339.             choice = OSBTN_YES;
  2340.         }
  2342.         if (OSBTN_YES == choice)
  2343.         {
  2344.             llinfos << "Sending crash report." << llendl;
  2345.             
  2346.             bool report_freeze = true;
  2347.             handleCrashReporting(report_freeze);
  2348.         }
  2349.         else
  2350.         {
  2351.             llinfos << "Not sending crash report." << llendl;
  2352.         }
  2353.     }
  2354. #endif // LL_SEND_CRASH_REPORTS    
  2355.     
  2356. }
  2358. bool LLAppViewer::initWindow()
  2359. {
  2360. LL_INFOS("AppInit") << "Initializing window..." << LL_ENDL;
  2362. // store setting in a global for easy access and modification
  2363. gNoRender = gSavedSettings.getBOOL("DisableRendering");
  2365. // always start windowed
  2366. BOOL ignorePixelDepth = gSavedSettings.getBOOL("IgnorePixelDepth");
  2367. gViewerWindow = new LLViewerWindow(gWindowTitle, 
  2368. VIEWER_WINDOW_CLASSNAME,
  2369. gSavedSettings.getS32("WindowX"), gSavedSettings.getS32("WindowY"),
  2370. gSavedSettings.getS32("WindowWidth"), gSavedSettings.getS32("WindowHeight"),
  2371. FALSE, ignorePixelDepth);
  2373. LLNotificationsUI::LLNotificationManager::getInstance();
  2375. if (gSavedSettings.getBOOL("WindowFullScreen"))
  2376. {
  2377. // request to go full screen... which will be delayed until login
  2378. gViewerWindow->toggleFullscreen(FALSE);
  2379. }
  2381. if (gSavedSettings.getBOOL("WindowMaximized"))
  2382. {
  2383. gViewerWindow->mWindow->maximize();
  2384. gViewerWindow->getWindow()->setNativeAspectRatio(gSavedSettings.getF32("FullScreenAspectRatio"));
  2385. }
  2387. if (!gNoRender)
  2388. {
  2389. //
  2390. // Initialize GL stuff
  2391. //
  2393. if (mForceGraphicsDetail)
  2394. {
  2395. LLFeatureManager::getInstance()->setGraphicsLevel(gSavedSettings.getU32("RenderQualityPerformance"), false);
  2396. }
  2398. // Set this flag in case we crash while initializing GL
  2399. gSavedSettings.setBOOL("RenderInitError", TRUE);
  2400. gSavedSettings.saveToFile( gSavedSettings.getString("ClientSettingsFile"), TRUE );
  2402. gPipeline.init();
  2403. stop_glerror();
  2404. gViewerWindow->initGLDefaults();
  2406. gSavedSettings.setBOOL("RenderInitError", FALSE);
  2407. gSavedSettings.saveToFile( gSavedSettings.getString("ClientSettingsFile"), TRUE );
  2408. }
  2410. //If we have a startup crash, it's usually near GL initialization, so simulate that.
  2411. if(gCrashOnStartup)
  2412. {
  2413. LLAppViewer::instance()->forceErrorLLError();
  2414. }
  2416. LLUI::sWindow = gViewerWindow->getWindow();
  2418. // Show watch cursor
  2419. gViewerWindow->setCursor(UI_CURSOR_WAIT);
  2421. // Finish view initialization
  2422. gViewerWindow->initBase();
  2424. // show viewer window
  2425. //gViewerWindow->mWindow->show();
  2428. return true;
  2429. }
  2431. void LLAppViewer::writeDebugInfo()
  2432. {
  2433. std::string debug_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"debug_info.log");
  2434. llinfos << "Opening debug file " << debug_filename << llendl;
  2435. llofstream out_file(debug_filename);
  2436. LLSDSerialize::toPrettyXML(gDebugInfo, out_file);
  2437. out_file.close();
  2438. }
  2440. void LLAppViewer::cleanupSavedSettings()
  2441. {
  2442. gSavedSettings.setBOOL("MouseSun", FALSE);
  2444. gSavedSettings.setBOOL("UseEnergy", TRUE); // force toggle to turn off, since sends message to simulator
  2446. gSavedSettings.setBOOL("DebugWindowProc", gDebugWindowProc);
  2448. gSavedSettings.setBOOL("ShowObjectUpdates", gShowObjectUpdates);
  2450. if (!gNoRender)
  2451. {
  2452. if (gDebugView)
  2453. {
  2454. gSavedSettings.setBOOL("ShowDebugConsole", gDebugView->mDebugConsolep->getVisible());
  2455. }
  2456. }
  2458. // save window position if not fullscreen
  2459. // as we don't track it in callbacks
  2460. BOOL fullscreen = gViewerWindow->mWindow->getFullscreen();
  2461. BOOL maximized = gViewerWindow->mWindow->getMaximized();
  2462. if (!fullscreen && !maximized)
  2463. {
  2464. LLCoordScreen window_pos;
  2466. if (gViewerWindow->mWindow->getPosition(&window_pos))
  2467. {
  2468. gSavedSettings.setS32("WindowX", window_pos.mX);
  2469. gSavedSettings.setS32("WindowY", window_pos.mY);
  2470. }
  2471. }
  2473. gSavedSettings.setF32("MapScale", LLWorldMapView::sMapScale );
  2475. // Some things are cached in LLAgent.
  2476. if (gAgent.mInitialized)
  2477. {
  2478. gSavedSettings.setF32("RenderFarClip", gAgent.mDrawDistance);
  2479. }
  2480. }
  2482. void LLAppViewer::removeCacheFiles(const std::string& file_mask)
  2483. {
  2484. std::string mask = gDirUtilp->getDirDelimiter() + file_mask;
  2485. gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE, ""), mask);
  2486. }
  2488. void LLAppViewer::writeSystemInfo()
  2489. {
  2490. gDebugInfo["SLLog"] = LLError::logFileName();
  2492. gDebugInfo["ClientInfo"]["Name"] = gSavedSettings.getString("VersionChannelName");
  2493. gDebugInfo["ClientInfo"]["MajorVersion"] = LLVersionInfo::getMajor();
  2494. gDebugInfo["ClientInfo"]["MinorVersion"] = LLVersionInfo::getMinor();
  2495. gDebugInfo["ClientInfo"]["PatchVersion"] = LLVersionInfo::getPatch();
  2496. gDebugInfo["ClientInfo"]["BuildVersion"] = LLVersionInfo::getBuild();
  2498. gDebugInfo["CAFilename"] = gDirUtilp->getCAFile();
  2500. gDebugInfo["CPUInfo"]["CPUString"] = gSysCPU.getCPUString();
  2501. gDebugInfo["CPUInfo"]["CPUFamily"] = gSysCPU.getFamily();
  2502. gDebugInfo["CPUInfo"]["CPUMhz"] = gSysCPU.getMhz();
  2503. gDebugInfo["CPUInfo"]["CPUAltivec"] = gSysCPU.hasAltivec();
  2504. gDebugInfo["CPUInfo"]["CPUSSE"] = gSysCPU.hasSSE();
  2505. gDebugInfo["CPUInfo"]["CPUSSE2"] = gSysCPU.hasSSE2();
  2507. gDebugInfo["RAMInfo"]["Physical"] = (LLSD::Integer)(gSysMemory.getPhysicalMemoryKB());
  2508. gDebugInfo["RAMInfo"]["Allocated"] = (LLSD::Integer)(gMemoryAllocated>>10); // MB -> KB
  2509. gDebugInfo["OSInfo"] = getOSInfo().getOSStringSimple();
  2511. // The user is not logged on yet, but record the current grid choice login url
  2512. // which may have been the intended grid. This can b
  2513. gDebugInfo["GridName"] = LLViewerLogin::getInstance()->getGridLabel();
  2515. // *FIX:Mani - move this ddown in llappviewerwin32
  2516. #ifdef LL_WINDOWS
  2517. DWORD thread_id = GetCurrentThreadId();
  2518. gDebugInfo["MainloopThreadID"] = (S32)thread_id;
  2519. #endif
  2521. // "CrashNotHandled" is set here, while things are running well,
  2522. // in case of a freeze. If there is a freeze, the crash logger will be launched
  2523. // and can read this value from the debug_info.log.
  2524. // If the crash is handled by LLAppViewer::handleViewerCrash, ie not a freeze,
  2525. // then the value of "CrashNotHandled" will be set to true.
  2526. gDebugInfo["CrashNotHandled"] = (LLSD::Boolean)true;
  2528. // Dump some debugging info
  2529. LL_INFOS("SystemInfo") << LLTrans::getString("APP_NAME")
  2530. << " version " << LLVersionInfo::getShortVersion() << LL_ENDL;
  2532. // Dump the local time and time zone
  2533. time_t now;
  2534. time(&now);
  2535. char tbuffer[256]; /* Flawfinder: ignore */
  2536. strftime(tbuffer, 256, "%Y-%m-%dT%H:%M:%S %Z", localtime(&now));
  2537. LL_INFOS("SystemInfo") << "Local time: " << tbuffer << LL_ENDL;
  2539. // query some system information
  2540. LL_INFOS("SystemInfo") << "CPU info:n" << gSysCPU << LL_ENDL;
  2541. LL_INFOS("SystemInfo") << "Memory info:n" << gSysMemory << LL_ENDL;
  2542. LL_INFOS("SystemInfo") << "OS: " << getOSInfo().getOSStringSimple() << LL_ENDL;
  2543. LL_INFOS("SystemInfo") << "OS info: " << getOSInfo() << LL_ENDL;
  2545. writeDebugInfo(); // Save out debug_info.log early, in case of crash.
  2546. }
  2548. void LLAppViewer::handleSyncViewerCrash()
  2549. {
  2550. LLAppViewer* pApp = LLAppViewer::instance();
  2551. // Call to pure virtual, handled by platform specific llappviewer instance.
  2552. pApp->handleSyncCrashTrace(); 
  2553. }
  2555. void LLAppViewer::handleViewerCrash()
  2556. {
  2557. llinfos << "Handle viewer crash entry." << llendl;
  2559. //print out recorded call stacks if there are any.
  2560. LLError::LLCallStacks::print();
  2562. LLAppViewer* pApp = LLAppViewer::instance();
  2563. if (pApp->beingDebugged())
  2564. {
  2565. // This will drop us into the debugger.
  2566. abort();
  2567. }
  2569. // Returns whether a dialog was shown.
  2570. // Only do the logic in here once
  2571. if (pApp->mReportedCrash)
  2572. {
  2573. return;
  2574. }
  2575. pApp->mReportedCrash = TRUE;
  2577. // Make sure the watchdog gets turned off...
  2578. //  pApp->destroyMainloopTimeout(); // SJB: Bah. This causes the crash handler to hang, not sure why.
  2580. //We already do this in writeSystemInfo(), but we do it again here to make /sure/ we have a version
  2581. //to check against no matter what
  2582. gDebugInfo["ClientInfo"]["Name"] = gSavedSettings.getString("VersionChannelName");
  2584. gDebugInfo["ClientInfo"]["MajorVersion"] = LLVersionInfo::getMajor();
  2585. gDebugInfo["ClientInfo"]["MinorVersion"] = LLVersionInfo::getMinor();
  2586. gDebugInfo["ClientInfo"]["PatchVersion"] = LLVersionInfo::getPatch();
  2587. gDebugInfo["ClientInfo"]["BuildVersion"] = LLVersionInfo::getBuild();
  2589. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  2590. if ( parcel && parcel->getMusicURL()[0])
  2591. {
  2592. gDebugInfo["ParcelMusicURL"] = parcel->getMusicURL();
  2593. }
  2594. if ( parcel && parcel->getMediaURL()[0])
  2595. {
  2596. gDebugInfo["ParcelMediaURL"] = parcel->getMediaURL();
  2597. }
  2600. gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
  2601. gDebugInfo["CAFilename"] = gDirUtilp->getCAFile();
  2602. gDebugInfo["ViewerExePath"] = gDirUtilp->getExecutablePathAndName();
  2603. gDebugInfo["CurrentPath"] = gDirUtilp->getCurPath();
  2604. gDebugInfo["SessionLength"] = F32(LLFrameTimer::getElapsedSeconds());
  2605. gDebugInfo["StartupState"] = LLStartUp::getStartupStateString();
  2606. gDebugInfo["RAMInfo"]["Allocated"] = (LLSD::Integer) LLMemory::getCurrentRSS() >> 10;
  2607. gDebugInfo["FirstLogin"] = (LLSD::Boolean) gAgent.isFirstLogin();
  2608. gDebugInfo["FirstRunThisInstall"] = gSavedSettings.getBOOL("FirstRunThisInstall");
  2610. if(gLogoutInProgress)
  2611. {
  2612. gDebugInfo["LastExecEvent"] = LAST_EXEC_LOGOUT_CRASH;
  2613. }
  2614. else
  2615. {
  2616. gDebugInfo["LastExecEvent"] = gLLErrorActivated ? LAST_EXEC_LLERROR_CRASH : LAST_EXEC_OTHER_CRASH;
  2617. }
  2619. if(gAgent.getRegion())
  2620. {
  2621. gDebugInfo["CurrentSimHost"] = gAgent.getRegionHost().getHostName();
  2622. gDebugInfo["CurrentRegion"] = gAgent.getRegion()->getName();
  2624. const LLVector3& loc = gAgent.getPositionAgent();
  2625. gDebugInfo["CurrentLocationX"] = loc.mV[0];
  2626. gDebugInfo["CurrentLocationY"] = loc.mV[1];
  2627. gDebugInfo["CurrentLocationZ"] = loc.mV[2];
  2628. }
  2630. if(LLAppViewer::instance()->mMainloopTimeout)
  2631. {
  2632. gDebugInfo["MainloopTimeoutState"] = LLAppViewer::instance()->mMainloopTimeout->getState();
  2633. }
  2635. // The crash is being handled here so set this value to false.
  2636. // Otherwise the crash logger will think this crash was a freeze.
  2637. gDebugInfo["CrashNotHandled"] = (LLSD::Boolean)false;
  2638.     
  2639. //Write out the crash status file
  2640. //Use marker file style setup, as that's the simplest, especially since
  2641. //we're already in a crash situation
  2642. if (gDirUtilp)
  2643. {
  2644. std::string crash_file_name;
  2645. if(gLLErrorActivated) crash_file_name = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,LLERROR_MARKER_FILE_NAME);
  2646. else crash_file_name = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,ERROR_MARKER_FILE_NAME);
  2647. llinfos << "Creating crash marker file " << crash_file_name << llendl;
  2649. LLAPRFile crash_file ;
  2650. crash_file.open(crash_file_name, LL_APR_W);
  2651. if (crash_file.getFileHandle())
  2652. {
  2653. LL_INFOS("MarkerFile") << "Created crash marker file " << crash_file_name << LL_ENDL;
  2654. }
  2655. else
  2656. {
  2657. LL_WARNS("MarkerFile") << "Cannot create error marker file " << crash_file_name << LL_ENDL;
  2658. }
  2659. }
  2661. if (gMessageSystem && gDirUtilp)
  2662. {
  2663. std::string filename;
  2664. filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "stats.log");
  2665. llofstream file(filename, llofstream::binary);
  2666. if(file.good())
  2667. {
  2668. llinfos << "Handle viewer crash generating stats log." << llendl;
  2669. gMessageSystem->summarizeLogs(file);
  2670. file.close();
  2671. }
  2672. }
  2674. if (gMessageSystem)
  2675. {
  2676. gMessageSystem->getCircuitInfo(gDebugInfo["CircuitInfo"]);
  2677. gMessageSystem->stopLogging();
  2678. }
  2680. if (LLWorld::instanceExists()) LLWorld::getInstance()->getInfo(gDebugInfo);
  2682. // Close the debug file
  2683. pApp->writeDebugInfo();
  2685. LLError::logToFile("");
  2687. // On Mac, we send the report on the next run, since we need macs crash report
  2688. // for a stack trace, so we have to let it the app fail.
  2689. #if !LL_DARWIN
  2691. // Remove the marker file, since otherwise we'll spawn a process that'll keep it locked
  2692. if(gDebugInfo["LastExecEvent"].asInteger() == LAST_EXEC_LOGOUT_CRASH)
  2693. {
  2694. pApp->removeMarkerFile(true);
  2695. }
  2696. else
  2697. {
  2698. pApp->removeMarkerFile(false);
  2699. }
  2701. // Call to pure virtual, handled by platform specific llappviewer instance.
  2702. pApp->handleCrashReporting(); 
  2704. #endif //!LL_DARWIN
  2705.     
  2706. return;
  2707. }
  2709. bool LLAppViewer::anotherInstanceRunning()
  2710. {
  2711. // We create a marker file when the program starts and remove the file when it finishes.
  2712. // If the file is currently locked, that means another process is already running.
  2714. std::string marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, MARKER_FILE_NAME);
  2715. LL_DEBUGS("MarkerFile") << "Checking marker file for lock..." << LL_ENDL;
  2717. //Freeze case checks
  2718. if (LLAPRFile::isExist(marker_file, NULL, LL_APR_RB))
  2719. {
  2720. // File exists, try opening with write permissions
  2721. LLAPRFile outfile ;
  2722. outfile.open(marker_file, LL_APR_WB);
  2723. apr_file_t* fMarker = outfile.getFileHandle() ; 
  2724. if (!fMarker)
  2725. {
  2726. // Another instance is running. Skip the rest of these operations.
  2727. LL_INFOS("MarkerFile") << "Marker file is locked." << LL_ENDL;
  2728. return true;
  2729. }
  2730. if (apr_file_lock(fMarker, APR_FLOCK_NONBLOCK | APR_FLOCK_EXCLUSIVE) != APR_SUCCESS) //flock(fileno(fMarker), LOCK_EX | LOCK_NB) == -1)
  2731. {
  2732. LL_INFOS("MarkerFile") << "Marker file is locked." << LL_ENDL;
  2733. return true;
  2734. }
  2735. // No other instances; we'll lock this file now & delete on quit.
  2736. }
  2737. LL_DEBUGS("MarkerFile") << "Marker file isn't locked." << LL_ENDL;
  2738. return false;
  2739. }
  2741. void LLAppViewer::initMarkerFile()
  2742. {
  2743. //First, check for the existence of other files.
  2744. //There are marker files for two different types of crashes
  2746. mMarkerFileName = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,MARKER_FILE_NAME);
  2747. LL_DEBUGS("MarkerFile") << "Checking marker file for lock..." << LL_ENDL;
  2749. //We've got 4 things to test for here
  2750. // - Other Process Running (SecondLife.exec_marker present, locked)
  2751. // - Freeze (SecondLife.exec_marker present, not locked)
  2752. // - LLError Crash (SecondLife.llerror_marker present)
  2753. // - Other Crash (SecondLife.error_marker present)
  2754. // These checks should also remove these files for the last 2 cases if they currently exist
  2756. //LLError/Error checks. Only one of these should ever happen at a time.
  2757. std::string logout_marker_file =  gDirUtilp->getExpandedFilename(LL_PATH_LOGS, LOGOUT_MARKER_FILE_NAME);
  2758. std::string llerror_marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, LLERROR_MARKER_FILE_NAME);
  2759. std::string error_marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, ERROR_MARKER_FILE_NAME);
  2762. if (LLAPRFile::isExist(mMarkerFileName, NULL, LL_APR_RB) && !anotherInstanceRunning())
  2763. {
  2764. gLastExecEvent = LAST_EXEC_FROZE;
  2765. LL_INFOS("MarkerFile") << "Exec marker found: program froze on previous execution" << LL_ENDL;
  2766. }    
  2767.     
  2768. if(LLAPRFile::isExist(logout_marker_file, NULL, LL_APR_RB))
  2769. {
  2770. LL_INFOS("MarkerFile") << "Last exec LLError crashed, setting LastExecEvent to " << LAST_EXEC_LLERROR_CRASH << LL_ENDL;
  2771. gLastExecEvent = LAST_EXEC_LOGOUT_FROZE;
  2772. }
  2773. if(LLAPRFile::isExist(llerror_marker_file, NULL, LL_APR_RB))
  2774. {
  2775. llinfos << "Last exec LLError crashed, setting LastExecEvent to " << LAST_EXEC_LLERROR_CRASH << llendl;
  2776. if(gLastExecEvent == LAST_EXEC_LOGOUT_FROZE) gLastExecEvent = LAST_EXEC_LOGOUT_CRASH;
  2777. else gLastExecEvent = LAST_EXEC_LLERROR_CRASH;
  2778. }
  2779. if(LLAPRFile::isExist(error_marker_file, NULL, LL_APR_RB))
  2780. {
  2781. LL_INFOS("MarkerFile") << "Last exec crashed, setting LastExecEvent to " << LAST_EXEC_OTHER_CRASH << LL_ENDL;
  2782. if(gLastExecEvent == LAST_EXEC_LOGOUT_FROZE) gLastExecEvent = LAST_EXEC_LOGOUT_CRASH;
  2783. else gLastExecEvent = LAST_EXEC_OTHER_CRASH;
  2784. }
  2786. LLAPRFile::remove(logout_marker_file);
  2787. LLAPRFile::remove(llerror_marker_file);
  2788. LLAPRFile::remove(error_marker_file);
  2790. // No new markers if another instance is running.
  2791. if(anotherInstanceRunning()) 
  2792. {
  2793. return;
  2794. }
  2796. // Create the marker file for this execution & lock it
  2797. apr_status_t s;
  2798. s = mMarkerFile.open(mMarkerFileName, LL_APR_W, TRUE);
  2800. if (s == APR_SUCCESS && mMarkerFile.getFileHandle())
  2801. {
  2802. LL_DEBUGS("MarkerFile") << "Marker file created." << LL_ENDL;
  2803. }
  2804. else
  2805. {
  2806. LL_INFOS("MarkerFile") << "Failed to create marker file." << LL_ENDL;
  2807. return;
  2808. }
  2809. if (apr_file_lock(mMarkerFile.getFileHandle(), APR_FLOCK_NONBLOCK | APR_FLOCK_EXCLUSIVE) != APR_SUCCESS) 
  2810. {
  2811. mMarkerFile.close() ;
  2812. LL_INFOS("MarkerFile") << "Marker file cannot be locked." << LL_ENDL;
  2813. return;
  2814. }
  2816. LL_DEBUGS("MarkerFile") << "Marker file locked." << LL_ENDL;
  2817. }
  2819. void LLAppViewer::removeMarkerFile(bool leave_logout_marker)
  2820. {
  2821. LL_DEBUGS("MarkerFile") << "removeMarkerFile()" << LL_ENDL;
  2822. if (mMarkerFile.getFileHandle())
  2823. {
  2824. mMarkerFile.close() ;
  2825. LLAPRFile::remove( mMarkerFileName );
  2826. }
  2827. if (mLogoutMarkerFile != NULL && !leave_logout_marker)
  2828. {
  2829. LLAPRFile::remove( mLogoutMarkerFileName );
  2830. mLogoutMarkerFile = NULL;
  2831. }
  2832. }
  2834. void LLAppViewer::forceQuit()
  2835. { 
  2836. LLApp::setQuitting(); 
  2837. }
  2839. void LLAppViewer::requestQuit()
  2840. {
  2841. llinfos << "requestQuit" << llendl;
  2843. LLViewerRegion* region = gAgent.getRegion();
  2845. if( (LLStartUp::getStartupState() < STATE_STARTED) || !region )
  2846. {
  2847. // Quit immediately
  2848. forceQuit();
  2849. return;
  2850. }
  2852. LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral*)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINT, TRUE);
  2853. effectp->setPositionGlobal(gAgent.getPositionGlobal());
  2854. effectp->setColor(LLColor4U(gAgent.getEffectColor()));
  2855. LLHUDManager::getInstance()->sendEffects();
  2856. effectp->markDead() ;//remove it.
  2858. // Attempt to close all floaters that might be
  2859. // editing things.
  2860. if (gFloaterView)
  2861. {
  2862. // application is quitting
  2863. gFloaterView->closeAllChildren(true);
  2864. }
  2866. LLSideTray::getInstance()->notifyChildren(LLSD().with("request","quit"));
  2868. send_stats();
  2870. gLogoutTimer.reset();
  2871. mQuitRequested = true;
  2872. }
  2874. static bool finish_quit(const LLSD& notification, const LLSD& response)
  2875. {
  2876. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2878. if (option == 0)
  2879. {
  2880. LLAppViewer::instance()->requestQuit();
  2881. }
  2882. return false;
  2883. }
  2884. static LLNotificationFunctorRegistration finish_quit_reg("ConfirmQuit", finish_quit);
  2886. void LLAppViewer::userQuit()
  2887. {
  2888. if (gDisconnected)
  2889. {
  2890. requestQuit();
  2891. }
  2892. else
  2893. {
  2894. LLNotificationsUtil::add("ConfirmQuit");
  2895. }
  2896. }
  2898. static bool finish_early_exit(const LLSD& notification, const LLSD& response)
  2899. {
  2900. LLAppViewer::instance()->forceQuit();
  2901. return false;
  2902. }
  2904. void LLAppViewer::earlyExit(const std::string& name, const LLSD& substitutions)
  2905. {
  2906.     llwarns << "app_early_exit: " << name << llendl;
  2907. gDoDisconnect = TRUE;
  2908. LLNotificationsUtil::add(name, substitutions, LLSD(), finish_early_exit);
  2909. }
  2911. void LLAppViewer::forceExit(S32 arg)
  2912. {
  2913.     removeMarkerFile();
  2914.     
  2915.     // *FIX:Mani - This kind of exit hardly seems appropriate.
  2916.     exit(arg);
  2917. }
  2919. void LLAppViewer::abortQuit()
  2920. {
  2921.     llinfos << "abortQuit()" << llendl;
  2922. mQuitRequested = false;
  2923. }
  2925. void LLAppViewer::migrateCacheDirectory()
  2926. {
  2927. #if LL_WINDOWS || LL_DARWIN
  2928. // NOTE: (Nyx) as of 1.21, cache for mac is moving to /library/caches/SecondLife from
  2929. // /library/application support/SecondLife/cache This should clear/delete the old dir.
  2931. // As of 1.23 the Windows cache moved from
  2932. //   C:Documents and SettingsJamesApplication SupportSecondLifecache
  2933. // to
  2934. //   C:Documents and SettingsJamesLocal SettingsApplication SupportSecondLife
  2935. //
  2936. // The Windows Vista equivalent is from
  2937. //   C:UsersJamesAppDataRoamingSecondLifecache
  2938. // to
  2939. //   C:UsersJamesAppDataLocalSecondLife
  2940. //
  2941. // Note the absence of cache on the second path.  James.
  2943. // Only do this once per fresh install of this version.
  2944. if (gSavedSettings.getBOOL("MigrateCacheDirectory"))
  2945. {
  2946. gSavedSettings.setBOOL("MigrateCacheDirectory", FALSE);
  2948. std::string delimiter = gDirUtilp->getDirDelimiter();
  2949. std::string old_cache_dir = gDirUtilp->getOSUserAppDir() + delimiter + "cache";
  2950. std::string new_cache_dir = gDirUtilp->getCacheDir(true);
  2952. if (gDirUtilp->fileExists(old_cache_dir))
  2953. {
  2954. llinfos << "Migrating cache from " << old_cache_dir << " to " << new_cache_dir << llendl;
  2956. // Migrate inventory cache to avoid pain to inventory database after mass update
  2957. S32 file_count = 0;
  2958. std::string file_name;
  2959. std::string mask = delimiter + "*.*";
  2960. while (gDirUtilp->getNextFileInDir(old_cache_dir, mask, file_name, false))
  2961. {
  2962. if (file_name == "." || file_name == "..") continue;
  2963. std::string source_path = old_cache_dir + delimiter + file_name;
  2964. std::string dest_path = new_cache_dir + delimiter + file_name;
  2965. if (!LLFile::rename(source_path, dest_path))
  2966. {
  2967. file_count++;
  2968. }
  2969. }
  2970. llinfos << "Moved " << file_count << " files" << llendl;
  2972. // Nuke the old cache
  2973. gDirUtilp->setCacheDir(old_cache_dir);
  2974. purgeCache();
  2975. gDirUtilp->setCacheDir(new_cache_dir);
  2977. #if LL_DARWIN
  2978. // Clean up Mac files not deleted by removing *.*
  2979. std::string ds_store = old_cache_dir + "/.DS_Store";
  2980. if (gDirUtilp->fileExists(ds_store))
  2981. {
  2982. LLFile::remove(ds_store);
  2983. }
  2984. #endif
  2985. if (LLFile::rmdir(old_cache_dir) != 0)
  2986. {
  2987. llwarns << "could not delete old cache directory " << old_cache_dir << llendl;
  2988. }
  2989. }
  2990. }
  2991. #endif // LL_WINDOWS || LL_DARWIN
  2992. }
  2994. bool LLAppViewer::initCache()
  2995. {
  2996. mPurgeCache = false;
  2997. // Purge cache if user requested it
  2998. if (gSavedSettings.getBOOL("PurgeCacheOnStartup") ||
  2999. gSavedSettings.getBOOL("PurgeCacheOnNextStartup"))
  3000. {
  3001. gSavedSettings.setBOOL("PurgeCacheOnNextStartup", false);
  3002. mPurgeCache = true;
  3003. }
  3004. // Purge cache if it belongs to an old version
  3005. else
  3006. {
  3007. static const S32 cache_version = 6;
  3008. if (gSavedSettings.getS32("LocalCacheVersion") != cache_version)
  3009. {
  3010. mPurgeCache = true;
  3011. gSavedSettings.setS32("LocalCacheVersion", cache_version);
  3012. }
  3013. }
  3015. // We have moved the location of the cache directory over time.
  3016. migrateCacheDirectory();
  3018. // Setup and verify the cache location
  3019. std::string cache_location = gSavedSettings.getString("CacheLocation");
  3020. std::string new_cache_location = gSavedSettings.getString("NewCacheLocation");
  3021. if (new_cache_location != cache_location)
  3022. {
  3023. gDirUtilp->setCacheDir(gSavedSettings.getString("CacheLocation"));
  3024. purgeCache(); // purge old cache
  3025. gSavedSettings.setString("CacheLocation", new_cache_location);
  3026. gSavedSettings.setString("CacheLocationTopFolder", gDirUtilp->getBaseFileName(new_cache_location));
  3027. }
  3029. if (!gDirUtilp->setCacheDir(gSavedSettings.getString("CacheLocation")))
  3030. {
  3031. LL_WARNS("AppCache") << "Unable to set cache location" << LL_ENDL;
  3032. gSavedSettings.setString("CacheLocation", "");
  3033. gSavedSettings.setString("CacheLocationTopFolder", "");
  3034. }
  3036. if (mPurgeCache)
  3037. {
  3038. LLSplashScreen::update("Clearing cache...");
  3039. purgeCache();
  3040. }
  3042. LLSplashScreen::update("Initializing Texture Cache...");
  3044. // Init the texture cache
  3045. // Allocate 80% of the cache size for textures
  3046. BOOL read_only = mSecondInstance ? TRUE : FALSE;
  3047. const S32 MB = 1024*1024;
  3048. S64 cache_size = (S64)(gSavedSettings.getU32("CacheSize")) * MB;
  3049. const S64 MAX_CACHE_SIZE = 1024*MB;
  3050. cache_size = llmin(cache_size, MAX_CACHE_SIZE);
  3051. S64 texture_cache_size = ((cache_size * 8)/10);
  3052. S64 extra = LLAppViewer::getTextureCache()->initCache(LL_PATH_CACHE, texture_cache_size, read_only);
  3053. texture_cache_size -= extra;
  3055. LLSplashScreen::update("Initializing VFS...");
  3057. // Init the VFS
  3058. S64 vfs_size = cache_size - texture_cache_size;
  3059. const S64 MAX_VFS_SIZE = 1024 * MB; // 1 GB
  3060. vfs_size = llmin(vfs_size, MAX_VFS_SIZE);
  3061. vfs_size = (vfs_size / MB) * MB; // make sure it is MB aligned
  3062. U32 vfs_size_u32 = (U32)vfs_size;
  3063. U32 old_vfs_size = gSavedSettings.getU32("VFSOldSize") * MB;
  3064. bool resize_vfs = (vfs_size_u32 != old_vfs_size);
  3065. if (resize_vfs)
  3066. {
  3067. gSavedSettings.setU32("VFSOldSize", vfs_size_u32/MB);
  3068. }
  3069. LL_INFOS("AppCache") << "VFS CACHE SIZE: " << vfs_size/(1024*1024) << " MB" << LL_ENDL;
  3071. // This has to happen BEFORE starting the vfs
  3072. //time_t ltime;
  3073. srand(time(NULL)); // Flawfinder: ignore
  3074. U32 old_salt = gSavedSettings.getU32("VFSSalt");
  3075. U32 new_salt;
  3076. std::string old_vfs_data_file;
  3077. std::string old_vfs_index_file;
  3078. std::string new_vfs_data_file;
  3079. std::string new_vfs_index_file;
  3080. std::string static_vfs_index_file;
  3081. std::string static_vfs_data_file;
  3083. if (gSavedSettings.getBOOL("AllowMultipleViewers"))
  3084. {
  3085. // don't mess with renaming the VFS in this case
  3086. new_salt = old_salt;
  3087. }
  3088. else
  3089. {
  3090. do
  3091. {
  3092. new_salt = rand();
  3093. } while( new_salt == old_salt );
  3094. }
  3096. old_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,VFS_DATA_FILE_BASE) + llformat("%u",old_salt);
  3098. // make sure this file exists
  3099. llstat s;
  3100. S32 stat_result = LLFile::stat(old_vfs_data_file, &s);
  3101. if (stat_result)
  3102. {
  3103. // doesn't exist, look for a data file
  3104. std::string mask;
  3105. mask = gDirUtilp->getDirDelimiter();
  3106. mask += VFS_DATA_FILE_BASE;
  3107. mask += "*";
  3109. std::string dir;
  3110. dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"");
  3112. std::string found_file;
  3113. if (gDirUtilp->getNextFileInDir(dir, mask, found_file, false))
  3114. {
  3115. old_vfs_data_file = dir + gDirUtilp->getDirDelimiter() + found_file;
  3117. S32 start_pos = found_file.find_last_of('.');
  3118. if (start_pos > 0)
  3119. {
  3120. sscanf(found_file.substr(start_pos+1).c_str(), "%d", &old_salt);
  3121. }
  3122. LL_DEBUGS("AppCache") << "Default vfs data file not present, found: " << old_vfs_data_file << " Old salt: " << old_salt << llendl;
  3123. }
  3124. }
  3126. old_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,VFS_INDEX_FILE_BASE) + llformat("%u",old_salt);
  3128. stat_result = LLFile::stat(old_vfs_index_file, &s);
  3129. if (stat_result)
  3130. {
  3131. // We've got a bad/missing index file, nukem!
  3132. LL_WARNS("AppCache") << "Bad or missing vfx index file " << old_vfs_index_file << LL_ENDL;
  3133. LL_WARNS("AppCache") << "Removing old vfs data file " << old_vfs_data_file << LL_ENDL;
  3134. LLFile::remove(old_vfs_data_file);
  3135. LLFile::remove(old_vfs_index_file);
  3137. // Just in case, nuke any other old cache files in the directory.
  3138. std::string dir;
  3139. dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"");
  3141. std::string mask;
  3142. mask = gDirUtilp->getDirDelimiter();
  3143. mask += VFS_DATA_FILE_BASE;
  3144. mask += "*";
  3146. gDirUtilp->deleteFilesInDir(dir, mask);
  3148. mask = gDirUtilp->getDirDelimiter();
  3149. mask += VFS_INDEX_FILE_BASE;
  3150. mask += "*";
  3152. gDirUtilp->deleteFilesInDir(dir, mask);
  3153. }
  3155. new_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,VFS_DATA_FILE_BASE) + llformat("%u",new_salt);
  3156. new_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_INDEX_FILE_BASE) + llformat("%u",new_salt);
  3158. static_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"static_data.db2");
  3159. static_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"static_index.db2");
  3161. if (resize_vfs)
  3162. {
  3163. LL_DEBUGS("AppCache") << "Removing old vfs and re-sizing" << LL_ENDL;
  3165. LLFile::remove(old_vfs_data_file);
  3166. LLFile::remove(old_vfs_index_file);
  3167. }
  3168. else if (old_salt != new_salt)
  3169. {
  3170. // move the vfs files to a new name before opening
  3171. LL_DEBUGS("AppCache") << "Renaming " << old_vfs_data_file << " to " << new_vfs_data_file << LL_ENDL;
  3172. LL_DEBUGS("AppCache") << "Renaming " << old_vfs_index_file << " to " << new_vfs_index_file << LL_ENDL;
  3173. LLFile::rename(old_vfs_data_file, new_vfs_data_file);
  3174. LLFile::rename(old_vfs_index_file, new_vfs_index_file);
  3175. }
  3177. // Startup the VFS...
  3178. gSavedSettings.setU32("VFSSalt", new_salt);
  3180. // Don't remove VFS after viewer crashes.  If user has corrupt data, they can reinstall. JC
  3181. gVFS = LLVFS::createLLVFS(new_vfs_index_file, new_vfs_data_file, false, vfs_size_u32, false);
  3182. if( !gVFS )
  3183. {
  3184. return false;
  3185. }
  3187. gStaticVFS = LLVFS::createLLVFS(static_vfs_index_file, static_vfs_data_file, true, 0, false);
  3188. if( !gStaticVFS )
  3189. {
  3190. return false;
  3191. }
  3193. BOOL success = gVFS->isValid() && gStaticVFS->isValid();
  3194. if( !success )
  3195. {
  3196. return false;
  3197. }
  3198. else
  3199. {
  3200. LLVFile::initClass();
  3201. return true;
  3202. }
  3203. }
  3205. void LLAppViewer::purgeCache()
  3206. {
  3207. LL_INFOS("AppCache") << "Purging Cache and Texture Cache..." << llendl;
  3208. LLAppViewer::getTextureCache()->purgeCache(LL_PATH_CACHE);
  3209. std::string mask = gDirUtilp->getDirDelimiter() + "*.*";
  3210. gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,""),mask);
  3211. }
  3213. std::string LLAppViewer::getSecondLifeTitle() const
  3214. {
  3215. return LLTrans::getString("APP_NAME");
  3216. }
  3218. std::string LLAppViewer::getWindowTitle() const 
  3219. {
  3220. return gWindowTitle;
  3221. }
  3223. // Callback from a dialog indicating user was logged out.  
  3224. bool finish_disconnect(const LLSD& notification, const LLSD& response)
  3225. {
  3226. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  3228. if (1 == option)
  3229. {
  3230.         LLAppViewer::instance()->forceQuit();
  3231. }
  3232. return false;
  3233. }
  3235. // Callback from an early disconnect dialog, force an exit
  3236. bool finish_forced_disconnect(const LLSD& notification, const LLSD& response)
  3237. {
  3238. LLAppViewer::instance()->forceQuit();
  3239. return false;
  3240. }
  3243. void LLAppViewer::forceDisconnect(const std::string& mesg)
  3244. {
  3245. if (gDoDisconnect)
  3246.     {
  3247. // Already popped up one of these dialogs, don't
  3248. // do this again.
  3249. return;
  3250.     }
  3252. // *TODO: Translate the message if possible
  3253. std::string big_reason = LLAgent::sTeleportErrorMessages[mesg];
  3254. if ( big_reason.size() == 0 )
  3255. {
  3256. big_reason = mesg;
  3257. }
  3259. LLSD args;
  3260. gDoDisconnect = TRUE;
  3262. if (LLStartUp::getStartupState() < STATE_STARTED)
  3263. {
  3264. // Tell users what happened
  3265. args["ERROR_MESSAGE"] = big_reason;
  3266. LLNotificationsUtil::add("ErrorMessage", args, LLSD(), &finish_forced_disconnect);
  3267. }
  3268. else
  3269. {
  3270. args["MESSAGE"] = big_reason;
  3271. LLNotificationsUtil::add("YouHaveBeenLoggedOut", args, LLSD(), &finish_disconnect );
  3272. }
  3273. }
  3275. void LLAppViewer::badNetworkHandler()
  3276. {
  3277. // Dump the packet
  3278. gMessageSystem->dumpPacketToLog();
  3280. // Flush all of our caches on exit in the case of disconnect due to
  3281. // invalid packets.
  3283. mPurgeOnExit = TRUE;
  3285. #if LL_WINDOWS
  3286. // Generates the minidump.
  3287. LLWinDebug::generateCrashStacks(NULL);
  3288. #endif
  3289. LLAppViewer::handleSyncViewerCrash();
  3290. LLAppViewer::handleViewerCrash();
  3292. std::ostringstream message;
  3293. message <<
  3294. "The viewer has detected mangled network data indicativen"
  3295. "of a bad upstream network connection or an incompleten"
  3296. "local installation of " << LLAppViewer::instance()->getSecondLifeTitle() << ". n"
  3297. " n"
  3298. "Try uninstalling and reinstalling to see if this resolves n"
  3299. "the issue. n"
  3300. " n"
  3301. "If the problem continues, see the Tech Support FAQ at: n"
  3302. "www.secondlife.com/support";
  3303. forceDisconnect(message.str());
  3304. }
  3306. // This routine may get called more than once during the shutdown process.
  3307. // This can happen because we need to get the screenshot before the window
  3308. // is destroyed.
  3309. void LLAppViewer::saveFinalSnapshot()
  3310. {
  3311. if (!mSavedFinalSnapshot && !gNoRender)
  3312. {
  3313. gSavedSettings.setVector3d("FocusPosOnLogout", gAgent.calcFocusPositionTargetGlobal());
  3314. gSavedSettings.setVector3d("CameraPosOnLogout", gAgent.calcCameraPositionTargetGlobal());
  3315. gViewerWindow->setCursor(UI_CURSOR_WAIT);
  3316. gAgent.changeCameraToThirdPerson( FALSE ); // don't animate, need immediate switch
  3317. gSavedSettings.setBOOL("ShowParcelOwners", FALSE);
  3318. idle();
  3320. std::string snap_filename = gDirUtilp->getLindenUserDir();
  3321. snap_filename += gDirUtilp->getDirDelimiter();
  3322. snap_filename += SCREEN_LAST_FILENAME;
  3323. // use full pixel dimensions of viewer window (not post-scale dimensions)
  3324. gViewerWindow->saveSnapshot(snap_filename, gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw(), FALSE, TRUE);
  3325. mSavedFinalSnapshot = TRUE;
  3326. }
  3327. }
  3329. void LLAppViewer::loadNameCache()
  3330. {
  3331. if (!gCacheName) return;
  3333. std::string name_cache;
  3334. name_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "name.cache");
  3335. llifstream cache_file(name_cache);
  3336. if(cache_file.is_open())
  3337. {
  3338. if(gCacheName->importFile(cache_file)) return;
  3339. }
  3341. // Try to load from the legacy format. This should go away after a
  3342. // while. Phoenix 2008-01-30
  3343. LLFILE* name_cache_fp = LLFile::fopen(name_cache, "r"); // Flawfinder: ignore
  3344. if (name_cache_fp)
  3345. {
  3346. gCacheName->importFile(name_cache_fp);
  3347. fclose(name_cache_fp);
  3348. }
  3349. }
  3351. void LLAppViewer::saveNameCache()
  3352. {
  3353. if (!gCacheName) return;
  3355. std::string name_cache;
  3356. name_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "name.cache");
  3357. llofstream cache_file(name_cache);
  3358. if(cache_file.is_open())
  3359. {
  3360. gCacheName->exportFile(cache_file);
  3361. }
  3362. }
  3364. /*! @brief This class is an LLFrameTimer that can be created with
  3365. an elapsed time that starts counting up from the given value
  3366. rather than 0.0.
  3368. Otherwise it behaves the same way as LLFrameTimer.
  3369. */
  3370. class LLFrameStatsTimer : public LLFrameTimer
  3371. {
  3372. public:
  3373. LLFrameStatsTimer(F64 elapsed_already = 0.0)
  3374. : LLFrameTimer()
  3375. {
  3376. mStartTime -= elapsed_already;
  3377. }
  3378. };
  3380. static LLFastTimer::DeclareTimer FTM_AUDIO_UPDATE("Update Audio");
  3381. static LLFastTimer::DeclareTimer FTM_CLEANUP("Cleanup");
  3382. static LLFastTimer::DeclareTimer FTM_IDLE_CB("Idle Callbacks");
  3383. static LLFastTimer::DeclareTimer FTM_LOD_UPDATE("Update LOD");
  3384. static LLFastTimer::DeclareTimer FTM_OBJECTLIST_UPDATE("Update Objectlist");
  3385. static LLFastTimer::DeclareTimer FTM_REGION_UPDATE("Update Region");
  3386. static LLFastTimer::DeclareTimer FTM_WORLD_UPDATE("Update World");
  3387. static LLFastTimer::DeclareTimer FTM_NETWORK("Network");
  3389. ///////////////////////////////////////////////////////
  3390. // idle()
  3391. //
  3392. // Called every time the window is not doing anything.
  3393. // Receive packets, update statistics, and schedule a redisplay.
  3394. ///////////////////////////////////////////////////////
  3395. void LLAppViewer::idle()
  3396. {
  3397. LLMemType mt_idle(LLMemType::MTYPE_IDLE);
  3398. pingMainloopTimeout("Main:Idle");
  3400. // Update frame timers
  3401. static LLTimer idle_timer;
  3403. LLFrameTimer::updateFrameTime();
  3404. LLFrameTimer::updateFrameCount();
  3405. LLEventTimer::updateClass();
  3406. LLCriticalDamp::updateInterpolants();
  3407. LLMortician::updateClass();
  3408. F32 dt_raw = idle_timer.getElapsedTimeAndResetF32();
  3410. // Cap out-of-control frame times
  3411. // Too low because in menus, swapping, debugger, etc.
  3412. // Too high because idle called with no objects in view, etc.
  3413. const F32 MIN_FRAME_RATE = 1.f;
  3414. const F32 MAX_FRAME_RATE = 200.f;
  3416. F32 frame_rate_clamped = 1.f / dt_raw;
  3417. frame_rate_clamped = llclamp(frame_rate_clamped, MIN_FRAME_RATE, MAX_FRAME_RATE);
  3418. gFrameDTClamped = 1.f / frame_rate_clamped;
  3420. // Global frame timer
  3421. // Smoothly weight toward current frame
  3422. gFPSClamped = (frame_rate_clamped + (4.f * gFPSClamped)) / 5.f;
  3424. F32 qas = gSavedSettings.getF32("QuitAfterSeconds");
  3425. if (qas > 0.f)
  3426. {
  3427. if (gRenderStartTime.getElapsedTimeF32() > qas)
  3428. {
  3429. LLAppViewer::instance()->forceQuit();
  3430. }
  3431. }
  3433. // Must wait until both have avatar object and mute list, so poll
  3434. // here.
  3435. request_initial_instant_messages();
  3437. ///////////////////////////////////
  3438. //
  3439. // Special case idle if still starting up
  3440. //
  3441. if (LLStartUp::getStartupState() < STATE_STARTED)
  3442. {
  3443. // Skip rest if idle startup returns false (essentially, no world yet)
  3444. gGLActive = TRUE;
  3445. if (!idle_startup())
  3446. {
  3447. gGLActive = FALSE;
  3448. return;
  3449. }
  3450. gGLActive = FALSE;
  3451. }
  3454.     F32 yaw = 0.f; // radians
  3456. if (!gDisconnected)
  3457. {
  3458. LLFastTimer t(FTM_NETWORK);
  3459. // Update spaceserver timeinfo
  3460.     LLWorld::getInstance()->setSpaceTimeUSec(LLWorld::getInstance()->getSpaceTimeUSec() + (U32)(dt_raw * SEC_TO_MICROSEC));
  3461.     
  3462.     
  3463.     //////////////////////////////////////
  3464.     //
  3465.     // Update simulator agent state
  3466.     //
  3468. if (gSavedSettings.getBOOL("RotateRight"))
  3469. {
  3470. gAgent.moveYaw(-1.f);
  3471. }
  3473.     // Handle automatic walking towards points
  3474.     gAgentPilot.updateTarget();
  3475.     gAgent.autoPilot(&yaw);
  3476.     
  3477.     static LLFrameTimer agent_update_timer;
  3478.     static U32  last_control_flags;
  3479.     
  3480.     // When appropriate, update agent location to the simulator.
  3481.     F32 agent_update_time = agent_update_timer.getElapsedTimeF32();
  3482.     BOOL flags_changed = gAgent.controlFlagsDirty() || (last_control_flags != gAgent.getControlFlags());
  3483.     
  3484.     if (flags_changed || (agent_update_time > (1.0f / (F32) AGENT_UPDATES_PER_SECOND)))
  3485.     {
  3486.     // Send avatar and camera info
  3487.     last_control_flags = gAgent.getControlFlags();
  3488.     send_agent_update(TRUE);
  3489.     agent_update_timer.reset();
  3490.     }
  3491. }
  3493. //////////////////////////////////////
  3494. //
  3495. // Manage statistics
  3496. //
  3497. //
  3498. {
  3499. // Initialize the viewer_stats_timer with an already elapsed time
  3500. // of SEND_STATS_PERIOD so that the initial stats report will
  3501. // be sent immediately.
  3502. static LLFrameStatsTimer viewer_stats_timer(SEND_STATS_PERIOD);
  3503. reset_statistics();
  3505. // Update session stats every large chunk of time
  3506. // *FIX: (???) SAMANTHA
  3507. if (viewer_stats_timer.getElapsedTimeF32() >= SEND_STATS_PERIOD && !gDisconnected)
  3508. {
  3509. llinfos << "Transmitting sessions stats" << llendl;
  3510. send_stats();
  3511. viewer_stats_timer.reset();
  3512. }
  3514. // Print the object debugging stats
  3515. static LLFrameTimer object_debug_timer;
  3516. if (object_debug_timer.getElapsedTimeF32() > 5.f)
  3517. {
  3518. object_debug_timer.reset();
  3519. if (gObjectList.mNumDeadObjectUpdates)
  3520. {
  3521. llinfos << "Dead object updates: " << gObjectList.mNumDeadObjectUpdates << llendl;
  3522. gObjectList.mNumDeadObjectUpdates = 0;
  3523. }
  3524. if (gObjectList.mNumUnknownKills)
  3525. {
  3526. llinfos << "Kills on unknown objects: " << gObjectList.mNumUnknownKills << llendl;
  3527. gObjectList.mNumUnknownKills = 0;
  3528. }
  3529. if (gObjectList.mNumUnknownUpdates)
  3530. {
  3531. llinfos << "Unknown object updates: " << gObjectList.mNumUnknownUpdates << llendl;
  3532. gObjectList.mNumUnknownUpdates = 0;
  3533. }
  3534. }
  3535. }
  3537. if (!gDisconnected)
  3538. {
  3539. LLFastTimer t(FTM_NETWORK);
  3541.     ////////////////////////////////////////////////
  3542.     //
  3543.     // Network processing
  3544.     //
  3545.     // NOTE: Starting at this point, we may still have pointers to "dead" objects
  3546.     // floating throughout the various object lists.
  3547.     //
  3548.     
  3549. idleNetwork();
  3550.              
  3552. // Check for away from keyboard, kick idle agents.
  3553. idle_afk_check();
  3555. //  Update statistics for this frame
  3556. update_statistics(gFrameCount);
  3557. }
  3559. ////////////////////////////////////////
  3560. //
  3561. // Handle the regular UI idle callbacks as well as
  3562. // hover callbacks
  3563. //
  3565. {
  3566. //  LLFastTimer t(FTM_IDLE_CB);
  3568. // Do event notifications if necessary.  Yes, we may want to move this elsewhere.
  3569. gEventNotifier.update();
  3571. gIdleCallbacks.callFunctions();
  3572. gInventory.idleNotifyObservers();
  3573. }
  3575. if (gDisconnected)
  3576.     {
  3577. return;
  3578.     }
  3580. gViewerWindow->updateUI();
  3582. ///////////////////////////////////////
  3583. // Agent and camera movement
  3584. //
  3585. LLCoordGL current_mouse = gViewerWindow->getCurrentMouse();
  3587. {
  3588. // After agent and camera moved, figure out if we need to
  3589. // deselect objects.
  3590. LLSelectMgr::getInstance()->deselectAllIfTooFar();
  3592. }
  3594. {
  3595. // Handle pending gesture processing
  3596. LLGestureManager::instance().update();
  3598. gAgent.updateAgentPosition(gFrameDTClamped, yaw, current_mouse.mX, current_mouse.mY);
  3599. }
  3601. {
  3602. LLFastTimer t(FTM_OBJECTLIST_UPDATE); // Actually "object update"
  3604.         if (!(logoutRequestSent() && hasSavedFinalSnapshot()))
  3605. {
  3606. gObjectList.update(gAgent, *LLWorld::getInstance());
  3607. }
  3608. }
  3610. //////////////////////////////////////
  3611. //
  3612. // Deletes objects...
  3613. // Has to be done after doing idleUpdates (which can kill objects)
  3614. //
  3616. {
  3617. LLFastTimer t(FTM_CLEANUP);
  3618. gObjectList.cleanDeadObjects();
  3619. LLDrawable::cleanupDeadDrawables();
  3620. }
  3622. //
  3623. // After this point, in theory we should never see a dead object
  3624. // in the various object/drawable lists.
  3625. //
  3627. //////////////////////////////////////
  3628. //
  3629. // Update/send HUD effects
  3630. //
  3631. // At this point, HUD effects may clean up some references to
  3632. // dead objects.
  3633. //
  3635. {
  3636. LLSelectMgr::getInstance()->updateEffects();
  3637. LLHUDManager::getInstance()->cleanupEffects();
  3638. LLHUDManager::getInstance()->sendEffects();
  3639. }
  3641. ////////////////////////////////////////
  3642. //
  3643. // Unpack layer data that we've received
  3644. //
  3646. {
  3647. LLFastTimer t(FTM_NETWORK);
  3648. gVLManager.unpackData();
  3649. }
  3651. /////////////////////////
  3652. //
  3653. // Update surfaces, and surface textures as well.
  3654. //
  3656. LLWorld::getInstance()->updateVisibilities();
  3657. {
  3658. const F32 max_region_update_time = .001f; // 1ms
  3659. LLFastTimer t(FTM_REGION_UPDATE);
  3660. LLWorld::getInstance()->updateRegions(max_region_update_time);
  3661. }
  3663. /////////////////////////
  3664. //
  3665. // Update weather effects
  3666. //
  3667. if (!gNoRender)
  3668. {
  3669. LLWorld::getInstance()->updateClouds(gFrameDTClamped);
  3670. gSky.propagateHeavenlyBodies(gFrameDTClamped); // moves sun, moon, and planets
  3672. // Update wind vector 
  3673. LLVector3 wind_position_region;
  3674. static LLVector3 average_wind;
  3676. LLViewerRegion *regionp;
  3677. regionp = LLWorld::getInstance()->resolveRegionGlobal(wind_position_region, gAgent.getPositionGlobal()); // puts agent's local coords into wind_position
  3678. if (regionp)
  3679. {
  3680. gWindVec = regionp->mWind.getVelocity(wind_position_region);
  3682. // Compute average wind and use to drive motion of water
  3684. average_wind = regionp->mWind.getAverage();
  3685. F32 cloud_density = regionp->mCloudLayer.getDensityRegion(wind_position_region);
  3687. gSky.setCloudDensityAtAgent(cloud_density);
  3688. gSky.setWind(average_wind);
  3689. //LLVOWater::setWind(average_wind);
  3690. }
  3691. else
  3692. {
  3693. gWindVec.setVec(0.0f, 0.0f, 0.0f);
  3694. }
  3695. }
  3697. //////////////////////////////////////
  3698. //
  3699. // Sort and cull in the new renderer are moved to pipeline.cpp
  3700. // Here, particles are updated and drawables are moved.
  3701. //
  3703. if (!gNoRender)
  3704. {
  3705. LLFastTimer t(FTM_WORLD_UPDATE);
  3706. gPipeline.updateMove();
  3708. LLWorld::getInstance()->updateParticles();
  3709. }
  3711. if (LLViewerJoystick::getInstance()->getOverrideCamera())
  3712. {
  3713. LLViewerJoystick::getInstance()->moveFlycam();
  3714. }
  3715. else
  3716. {
  3717. if (LLToolMgr::getInstance()->inBuildMode())
  3718. {
  3719. LLViewerJoystick::getInstance()->moveObjects();
  3720. }
  3722. gAgent.updateCamera();
  3723. }
  3725. // update media focus
  3726. LLViewerMediaFocus::getInstance()->update();
  3728. // objects and camera should be in sync, do LOD calculations now
  3729. {
  3730. LLFastTimer t(FTM_LOD_UPDATE);
  3731. gObjectList.updateApparentAngles(gAgent);
  3732. }
  3734. {
  3735. LLFastTimer t(FTM_AUDIO_UPDATE);
  3737. if (gAudiop)
  3738. {
  3739.     audio_update_volume(false);
  3740. audio_update_listener();
  3741. audio_update_wind(false);
  3743. // this line actually commits the changes we've made to source positions, etc.
  3744. const F32 max_audio_decode_time = 0.002f; // 2 ms decode time
  3745. gAudiop->idle(max_audio_decode_time);
  3746. }
  3747. }
  3749. // Handle shutdown process, for example, 
  3750. // wait for floaters to close, send quit message,
  3751. // forcibly quit if it has taken too long
  3752. if (mQuitRequested)
  3753. {
  3754. gGLActive = TRUE;
  3755. idleShutdown();
  3756. }
  3757. }
  3759. void LLAppViewer::idleShutdown()
  3760. {
  3761. // Wait for all modal alerts to get resolved
  3762. if (LLModalDialog::activeCount() > 0)
  3763. {
  3764. return;
  3765. }
  3767. // close IM interface
  3768. if(gIMMgr)
  3769. {
  3770. gIMMgr->disconnectAllSessions();
  3771. }
  3773. // Wait for all floaters to get resolved
  3774. if (gFloaterView
  3775. && !gFloaterView->allChildrenClosed())
  3776. {
  3777. return;
  3778. }
  3780. if (LLSideTray::getInstance()->notifyChildren(LLSD().with("request","wait_quit")))
  3781. {
  3782. return;
  3783. }
  3787. // ProductEngine: Try moving this code to where we shut down sTextureCache in cleanup()
  3788. // *TODO: ugly
  3789. static bool saved_teleport_history = false;
  3790. if (!saved_teleport_history)
  3791. {
  3792. saved_teleport_history = true;
  3793. LLTeleportHistory::getInstance()->dump();
  3794. LLLocationHistory::getInstance()->save(); // *TODO: find a better place for doing this
  3795. return;
  3796. }
  3798. static bool saved_snapshot = false;
  3799. if (!saved_snapshot)
  3800. {
  3801. saved_snapshot = true;
  3802. saveFinalSnapshot();
  3803. return;
  3804. }
  3806. const F32 SHUTDOWN_UPLOAD_SAVE_TIME = 5.f;
  3808. S32 pending_uploads = gAssetStorage->getNumPendingUploads();
  3809. if (pending_uploads > 0
  3810. && gLogoutTimer.getElapsedTimeF32() < SHUTDOWN_UPLOAD_SAVE_TIME
  3811. && !logoutRequestSent())
  3812. {
  3813. static S32 total_uploads = 0;
  3814. // Sometimes total upload count can change during logout.
  3815. total_uploads = llmax(total_uploads, pending_uploads);
  3816. gViewerWindow->setShowProgress(TRUE);
  3817. S32 finished_uploads = total_uploads - pending_uploads;
  3818. F32 percent = 100.f * finished_uploads / total_uploads;
  3819. gViewerWindow->setProgressPercent(percent);
  3820. gViewerWindow->setProgressString("Saving your settings...");
  3821. return;
  3822. }
  3824. // All floaters are closed.  Tell server we want to quit.
  3825. if( !logoutRequestSent() )
  3826. {
  3827. sendLogoutRequest();
  3829. // Wait for a LogoutReply message
  3830. gViewerWindow->setShowProgress(TRUE);
  3831. gViewerWindow->setProgressPercent(100.f);
  3832. gViewerWindow->setProgressString("Logging out...");
  3833. return;
  3834. }
  3836. // Make sure that we quit if we haven't received a reply from the server.
  3837. if( logoutRequestSent() 
  3838. && gLogoutTimer.getElapsedTimeF32() > gLogoutMaxTime )
  3839. {
  3840. forceQuit();
  3841. return;
  3842. }
  3843. }
  3845. void LLAppViewer::sendLogoutRequest()
  3846. {
  3847. if(!mLogoutRequestSent)
  3848. {
  3849. LLMessageSystem* msg = gMessageSystem;
  3850. msg->newMessageFast(_PREHASH_LogoutRequest);
  3851. msg->nextBlockFast(_PREHASH_AgentData);
  3852. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  3853. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  3854. gAgent.sendReliableMessage();
  3856. gLogoutTimer.reset();
  3857. gLogoutMaxTime = LOGOUT_REQUEST_TIME;
  3858. mLogoutRequestSent = TRUE;
  3860. gVoiceClient->leaveChannel();
  3862. //Set internal status variables and marker files
  3863. gLogoutInProgress = TRUE;
  3864. mLogoutMarkerFileName = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,LOGOUT_MARKER_FILE_NAME);
  3866. LLAPRFile outfile ;
  3867. outfile.open(mLogoutMarkerFileName, LL_APR_W);
  3868. mLogoutMarkerFile =  outfile.getFileHandle() ;
  3869. if (mLogoutMarkerFile)
  3870. {
  3871. llinfos << "Created logout marker file " << mLogoutMarkerFileName << llendl;
  3872.      apr_file_close(mLogoutMarkerFile);
  3873. }
  3874. else
  3875. {
  3876. llwarns << "Cannot create logout marker file " << mLogoutMarkerFileName << llendl;
  3877. }
  3878. }
  3879. }
  3881. //
  3882. // Handle messages, and all message related stuff
  3883. //
  3885. #define TIME_THROTTLE_MESSAGES
  3887. #ifdef TIME_THROTTLE_MESSAGES
  3888. #define CHECK_MESSAGES_DEFAULT_MAX_TIME .020f // 50 ms = 50 fps (just for messages!)
  3889. static F32 CheckMessagesMaxTime = CHECK_MESSAGES_DEFAULT_MAX_TIME;
  3890. #endif
  3892. static LLFastTimer::DeclareTimer FTM_IDLE_NETWORK("Network");
  3894. void LLAppViewer::idleNetwork()
  3895. {
  3896. LLMemType mt_in(LLMemType::MTYPE_IDLE_NETWORK);
  3897. pingMainloopTimeout("idleNetwork");
  3898. LLError::LLCallStacks::clear() ;
  3899. llpushcallstacks ;
  3901. gObjectList.mNumNewObjects = 0;
  3902. S32 total_decoded = 0;
  3904. if (!gSavedSettings.getBOOL("SpeedTest"))
  3905. {
  3906. LLFastTimer t(FTM_IDLE_NETWORK); // decode
  3908. // deal with any queued name requests and replies.
  3909. gCacheName->processPending();
  3910. llpushcallstacks ;
  3911. LLTimer check_message_timer;
  3912. //  Read all available packets from network 
  3913. const S64 frame_count = gFrameCount;  // U32->S64
  3914. F32 total_time = 0.0f;
  3916. while (gMessageSystem->checkAllMessages(frame_count, gServicePump)) 
  3917. {
  3918. if (gDoDisconnect)
  3919. {
  3920. // We're disconnecting, don't process any more messages from the server
  3921. // We're usually disconnecting due to either network corruption or a
  3922. // server going down, so this is OK.
  3923. break;
  3924. }
  3926. total_decoded++;
  3927. gPacketsIn++;
  3929. if (total_decoded > MESSAGE_MAX_PER_FRAME)
  3930. {
  3931. break;
  3932. }
  3934. #ifdef TIME_THROTTLE_MESSAGES
  3935. // Prevent slow packets from completely destroying the frame rate.
  3936. // This usually happens due to clumps of avatars taking huge amount
  3937. // of network processing time (which needs to be fixed, but this is
  3938. // a good limit anyway).
  3939. total_time = check_message_timer.getElapsedTimeF32();
  3940. if (total_time >= CheckMessagesMaxTime)
  3941. break;
  3942. #endif
  3943. }
  3945. // Handle per-frame message system processing.
  3946. gMessageSystem->processAcks();
  3948. #ifdef TIME_THROTTLE_MESSAGES
  3949. if (total_time >= CheckMessagesMaxTime)
  3950. {
  3951. // Increase CheckMessagesMaxTime so that we will eventually catch up
  3952. CheckMessagesMaxTime *= 1.035f; // 3.5% ~= x2 in 20 frames, ~8x in 60 frames
  3953. }
  3954. else
  3955. {
  3956. // Reset CheckMessagesMaxTime to default value
  3957. CheckMessagesMaxTime = CHECK_MESSAGES_DEFAULT_MAX_TIME;
  3958. }
  3959. #endif
  3963. // we want to clear the control after sending out all necessary agent updates
  3964. gAgent.resetControlFlags();
  3966. // Decode enqueued messages...
  3967. S32 remaining_possible_decodes = MESSAGE_MAX_PER_FRAME - total_decoded;
  3969. if( remaining_possible_decodes <= 0 )
  3970. {
  3971. llinfos << "Maxed out number of messages per frame at " << MESSAGE_MAX_PER_FRAME << llendl;
  3972. }
  3974. if (gPrintMessagesThisFrame)
  3975. {
  3976. llinfos << "Decoded " << total_decoded << " msgs this frame!" << llendl;
  3977. gPrintMessagesThisFrame = FALSE;
  3978. }
  3979. }
  3980. llpushcallstacks ;
  3981. LLViewerStats::getInstance()->mNumNewObjectsStat.addValue(gObjectList.mNumNewObjects);
  3983. // Retransmit unacknowledged packets.
  3984. gXferManager->retransmitUnackedPackets();
  3985. gAssetStorage->checkForTimeouts();
  3986. llpushcallstacks ;
  3987. gViewerThrottle.updateDynamicThrottle();
  3989. llpushcallstacks ;
  3990. // Check that the circuit between the viewer and the agent's current
  3991. // region is still alive
  3992. LLViewerRegion *agent_region = gAgent.getRegion();
  3993. if (agent_region && (LLStartUp::getStartupState()==STATE_STARTED))
  3994. {
  3995. LLUUID this_region_id = agent_region->getRegionID();
  3996. bool this_region_alive = agent_region->isAlive();
  3997. if ((mAgentRegionLastAlive && !this_region_alive) // newly dead
  3998.     && (mAgentRegionLastID == this_region_id)) // same region
  3999. {
  4000. forceDisconnect(LLTrans::getString("AgentLostConnection"));
  4001. }
  4002. mAgentRegionLastID = this_region_id;
  4003. mAgentRegionLastAlive = this_region_alive;
  4004. }
  4005. llpushcallstacks ;
  4006. }
  4008. void LLAppViewer::disconnectViewer()
  4009. {
  4010. if (gDisconnected)
  4011. {
  4012. return;
  4013. }
  4014. //
  4015. // Cleanup after quitting.
  4016. //
  4017. // Save snapshot for next time, if we made it through initialization
  4019. llinfos << "Disconnecting viewer!" << llendl;
  4021. // Dump our frame statistics
  4023. // Remember if we were flying
  4024. gSavedSettings.setBOOL("FlyingAtExit", gAgent.getFlying() );
  4026. // Un-minimize all windows so they don't get saved minimized
  4027. if (!gNoRender)
  4028. {
  4029. if (gFloaterView)
  4030. {
  4031. gFloaterView->restoreAll();
  4032. }
  4033. }
  4035. if (LLSelectMgr::getInstance())
  4036. {
  4037. LLSelectMgr::getInstance()->deselectAll();
  4038. }
  4040. // save inventory if appropriate
  4041. gInventory.cache(gInventory.getRootFolderID(), gAgent.getID());
  4042. if (gInventory.getLibraryRootFolderID().notNull()
  4043. && gInventory.getLibraryOwnerID().notNull())
  4044. {
  4045. gInventory.cache(
  4046. gInventory.getLibraryRootFolderID(),
  4047. gInventory.getLibraryOwnerID());
  4048. }
  4050. saveNameCache();
  4052. // close inventory interface, close all windows
  4053. LLFloaterInventory::cleanup();
  4055. gAgentWearables.cleanup();
  4057. // Also writes cached agent settings to gSavedSettings
  4058. gAgent.cleanup();
  4060. // This is where we used to call gObjectList.destroy() and then delete gWorldp.
  4061. // Now we just ask the LLWorld singleton to cleanly shut down.
  4062. LLWorld::getInstance()->destroyClass();
  4064. // call all self-registered classes
  4065. LLDestroyClassList::instance().fireCallbacks();
  4067. cleanup_xfer_manager();
  4068. gDisconnected = TRUE;
  4069. }
  4071. void LLAppViewer::forceErrorLLError()
  4072. {
  4073.     llerrs << "This is an llerror" << llendl;
  4074. }
  4076. void LLAppViewer::forceErrorBreakpoint()
  4077. {
  4078. #ifdef LL_WINDOWS
  4079.     DebugBreak();
  4080. #endif
  4081.     return;
  4082. }
  4084. void LLAppViewer::forceErrorBadMemoryAccess()
  4085. {
  4086.     S32* crash = NULL;
  4087.     *crash = 0xDEADBEEF;
  4088.     return;
  4089. }
  4091. void LLAppViewer::forceErrorInfiniteLoop()
  4092. {
  4093.     while(true)
  4094.     {
  4095.         ;
  4096.     }
  4097.     return;
  4098. }
  4099.  
  4100. void LLAppViewer::forceErrorSoftwareException()
  4101. {
  4102.     // *FIX: Any way to insure it won't be handled?
  4103.     throw; 
  4104. }
  4106. void LLAppViewer::forceErrorDriverCrash()
  4107. {
  4108. glDeleteTextures(1, NULL);
  4109. }
  4111. void LLAppViewer::initMainloopTimeout(const std::string& state, F32 secs)
  4112. {
  4113. if(!mMainloopTimeout)
  4114. {
  4115. mMainloopTimeout = new LLWatchdogTimeout();
  4116. resumeMainloopTimeout(state, secs);
  4117. }
  4118. }
  4120. void LLAppViewer::destroyMainloopTimeout()
  4121. {
  4122. if(mMainloopTimeout)
  4123. {
  4124. delete mMainloopTimeout;
  4125. mMainloopTimeout = NULL;
  4126. }
  4127. }
  4129. void LLAppViewer::resumeMainloopTimeout(const std::string& state, F32 secs)
  4130. {
  4131. if(mMainloopTimeout)
  4132. {
  4133. if(secs < 0.0f)
  4134. {
  4135. secs = gSavedSettings.getF32("MainloopTimeoutDefault");
  4136. }
  4138. mMainloopTimeout->setTimeout(secs);
  4139. mMainloopTimeout->start(state);
  4140. }
  4141. }
  4143. void LLAppViewer::pauseMainloopTimeout()
  4144. {
  4145. if(mMainloopTimeout)
  4146. {
  4147. mMainloopTimeout->stop();
  4148. }
  4149. }
  4151. void LLAppViewer::pingMainloopTimeout(const std::string& state, F32 secs)
  4152. {
  4153. // if(!restoreErrorTrap())
  4154. // {
  4155. // llwarns << "!!!!!!!!!!!!! Its an error trap!!!!" << state << llendl;
  4156. // }
  4158. if(mMainloopTimeout)
  4159. {
  4160. if(secs < 0.0f)
  4161. {
  4162. secs = gSavedSettings.getF32("MainloopTimeoutDefault");
  4163. }
  4165. mMainloopTimeout->setTimeout(secs);
  4166. mMainloopTimeout->ping(state);
  4167. }
  4168. }
  4170. void LLAppViewer::handleLoginComplete()
  4171. {
  4172. initMainloopTimeout("Mainloop Init");
  4174. // Store some data to DebugInfo in case of a freeze.
  4175. gDebugInfo["ClientInfo"]["Name"] = gSavedSettings.getString("VersionChannelName");
  4177. gDebugInfo["ClientInfo"]["MajorVersion"] = LLVersionInfo::getMajor();
  4178. gDebugInfo["ClientInfo"]["MinorVersion"] = LLVersionInfo::getMinor();
  4179. gDebugInfo["ClientInfo"]["PatchVersion"] = LLVersionInfo::getPatch();
  4180. gDebugInfo["ClientInfo"]["BuildVersion"] = LLVersionInfo::getBuild();
  4182. LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  4183. if ( parcel && parcel->getMusicURL()[0])
  4184. {
  4185. gDebugInfo["ParcelMusicURL"] = parcel->getMusicURL();
  4186. }
  4187. if ( parcel && parcel->getMediaURL()[0])
  4188. {
  4189. gDebugInfo["ParcelMediaURL"] = parcel->getMediaURL();
  4190. }
  4192. gDebugInfo["SettingsFilename"] = gSavedSettings.getString("ClientSettingsFile");
  4193. gDebugInfo["CAFilename"] = gDirUtilp->getCAFile();
  4194. gDebugInfo["ViewerExePath"] = gDirUtilp->getExecutablePathAndName();
  4195. gDebugInfo["CurrentPath"] = gDirUtilp->getCurPath();
  4197. if(gAgent.getRegion())
  4198. {
  4199. gDebugInfo["CurrentSimHost"] = gAgent.getRegionHost().getHostName();
  4200. gDebugInfo["CurrentRegion"] = gAgent.getRegion()->getName();
  4201. }
  4203. if(LLAppViewer::instance()->mMainloopTimeout)
  4204. {
  4205. gDebugInfo["MainloopTimeoutState"] = LLAppViewer::instance()->mMainloopTimeout->getState();
  4206. }
  4208. mOnLoginCompleted();
  4210. writeDebugInfo();
  4211. }
  4213. // *TODO - generalize this and move DSO wrangling to a helper class -brad
  4214. void LLAppViewer::loadEventHostModule(S32 listen_port)
  4215. {
  4216. std::string dso_name =
  4217. #if LL_WINDOWS
  4218.     "lleventhost.dll";
  4219. #elif LL_DARWIN
  4220.     "liblleventhost.dylib";
  4221. #else
  4222.     "liblleventhost.so";
  4223. #endif
  4225. std::string dso_path = gDirUtilp->findFile(dso_name,
  4226. gDirUtilp->getAppRODataDir(),
  4227. gDirUtilp->getExecutableDir());
  4229. if(dso_path == "")
  4230. {
  4231. llerrs << "QAModeEventHost requested but module "" << dso_name << "" not found!" << llendl;
  4232. return;
  4233. }
  4235. apr_dso_handle_t * eventhost_dso_handle = NULL;
  4236. apr_pool_t * eventhost_dso_memory_pool = NULL;
  4238. //attempt to load the shared library
  4239. apr_pool_create(&eventhost_dso_memory_pool, NULL);
  4240. apr_status_t rv = apr_dso_load(&eventhost_dso_handle,
  4241. dso_path.c_str(),
  4242. eventhost_dso_memory_pool);
  4243. ll_apr_assert_status(rv);
  4244. llassert_always(eventhost_dso_handle != NULL);
  4246. int (*ll_plugin_start_func)(LLSD const &) = NULL;
  4247. rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll_plugin_start_func, eventhost_dso_handle, "ll_plugin_start");
  4249. ll_apr_assert_status(rv);
  4250. llassert_always(ll_plugin_start_func != NULL);
  4252. LLSD args;
  4253. args["listen_port"] = listen_port;
  4255. int status = ll_plugin_start_func(args);
  4257. if(status != 0)
  4258. {
  4259. llerrs << "problem loading eventhost plugin, status: " << status << llendl;
  4260. }
  4262. mPlugins.insert(eventhost_dso_handle);
  4263. }
  4265. void LLAppViewer::launchUpdater()
  4266. {
  4267. LLSD query_map = LLSD::emptyMap();
  4268. // *TODO place os string in a global constant
  4269. #if LL_WINDOWS  
  4270. query_map["os"] = "win";
  4271. #elif LL_DARWIN
  4272. query_map["os"] = "mac";
  4273. #elif LL_LINUX
  4274. query_map["os"] = "lnx";
  4275. #elif LL_SOLARIS
  4276. query_map["os"] = "sol";
  4277. #endif
  4278. // *TODO change userserver to be grid on both viewer and sim, since
  4279. // userserver no longer exists.
  4280. query_map["userserver"] = LLViewerLogin::getInstance()->getGridLabel();
  4281. query_map["channel"] = gSavedSettings.getString("VersionChannelName");
  4282. // *TODO constantize this guy
  4283. // *NOTE: This URL is also used in win_setup/lldownloader.cpp
  4284. LLURI update_url = LLURI::buildHTTP("secondlife.com", 80, "update.php", query_map);
  4286. if(LLAppViewer::sUpdaterInfo)
  4287. {
  4288. delete LLAppViewer::sUpdaterInfo;
  4289. }
  4290. LLAppViewer::sUpdaterInfo = new LLAppViewer::LLUpdaterInfo() ;
  4292. // if a sim name was passed in via command line parameter (typically through a SLURL)
  4293. if ( LLURLSimString::sInstance.mSimString.length() )
  4294. {
  4295. // record the location to start at next time
  4296. gSavedSettings.setString( "NextLoginLocation", LLURLSimString::sInstance.mSimString ); 
  4297. };
  4299. #if LL_WINDOWS
  4300. LLAppViewer::sUpdaterInfo->mUpdateExePath = gDirUtilp->getTempFilename();
  4301. if (LLAppViewer::sUpdaterInfo->mUpdateExePath.empty())
  4302. {
  4303. delete LLAppViewer::sUpdaterInfo ;
  4304. LLAppViewer::sUpdaterInfo = NULL ;
  4306. // We're hosed, bail
  4307. LL_WARNS("AppInit") << "LLDir::getTempFilename() failed" << LL_ENDL;
  4308. return;
  4309. }
  4311. LLAppViewer::sUpdaterInfo->mUpdateExePath += ".exe";
  4313. std::string updater_source = gDirUtilp->getAppRODataDir();
  4314. updater_source += gDirUtilp->getDirDelimiter();
  4315. updater_source += "updater.exe";
  4317. LL_DEBUGS("AppInit") << "Calling CopyFile source: " << updater_source
  4318. << " dest: " << LLAppViewer::sUpdaterInfo->mUpdateExePath
  4319. << LL_ENDL;
  4322. if (!CopyFileA(updater_source.c_str(), LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str(), FALSE))
  4323. {
  4324. delete LLAppViewer::sUpdaterInfo ;
  4325. LLAppViewer::sUpdaterInfo = NULL ;
  4327. LL_WARNS("AppInit") << "Unable to copy the updater!" << LL_ENDL;
  4329. return;
  4330. }
  4332. LLAppViewer::sUpdaterInfo->mParams << "-url "" << update_url.asString() << """;
  4334. LL_DEBUGS("AppInit") << "Calling updater: " << LLAppViewer::sUpdaterInfo->mUpdateExePath << " " << LLAppViewer::sUpdaterInfo->mParams.str() << LL_ENDL;
  4336. //Explicitly remove the marker file, otherwise we pass the lock onto the child process and things get weird.
  4337. LLAppViewer::instance()->removeMarkerFile(); // In case updater fails
  4339. // *NOTE:Mani The updater is spawned as the last thing before the WinMain exit.
  4340. // see LLAppViewerWin32.cpp
  4342. #elif LL_DARWIN
  4343. LLAppViewer::sUpdaterInfo->mUpdateExePath = "'";
  4344. LLAppViewer::sUpdaterInfo->mUpdateExePath += gDirUtilp->getAppRODataDir();
  4345. LLAppViewer::sUpdaterInfo->mUpdateExePath += "/mac-updater.app/Contents/MacOS/mac-updater' -url "";
  4346. LLAppViewer::sUpdaterInfo->mUpdateExePath += update_url.asString();
  4347. LLAppViewer::sUpdaterInfo->mUpdateExePath += "" -name "";
  4348. LLAppViewer::sUpdaterInfo->mUpdateExePath += LLAppViewer::instance()->getSecondLifeTitle();
  4349. LLAppViewer::sUpdaterInfo->mUpdateExePath += "" &";
  4351. LL_DEBUGS("AppInit") << "Calling updater: " << LLAppViewer::sUpdaterInfo->mUpdateExePath << LL_ENDL;
  4353. // Run the auto-updater.
  4354. system(LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str()); /* Flawfinder: ignore */
  4356. #elif (LL_LINUX || LL_SOLARIS) && LL_GTK
  4357. // we tell the updater where to find the xml containing string
  4358. // translations which it can use for its own UI
  4359. std::string xml_strings_file = "strings.xml";
  4360. std::vector<std::string> xui_path_vec = LLUI::getXUIPaths();
  4361. std::string xml_search_paths;
  4362. std::vector<std::string>::const_iterator iter;
  4363. // build comma-delimited list of xml paths to pass to updater
  4364. for (iter = xui_path_vec.begin(); iter != xui_path_vec.end(); )
  4365. {
  4366. std::string this_skin_dir = gDirUtilp->getDefaultSkinDir()
  4367. + gDirUtilp->getDirDelimiter()
  4368. + (*iter);
  4369. llinfos << "Got a XUI path: " << this_skin_dir << llendl;
  4370. xml_search_paths.append(this_skin_dir);
  4371. ++iter;
  4372. if (iter != xui_path_vec.end())
  4373. xml_search_paths.append(","); // comma-delimit
  4374. }
  4375. // build the overall command-line to run the updater correctly
  4376. LLAppViewer::sUpdaterInfo->mUpdateExePath = 
  4377. gDirUtilp->getExecutableDir() + "/" + "linux-updater.bin" + 
  4378. " --url "" + update_url.asString() + """ +
  4379. " --name "" + LLAppViewer::instance()->getSecondLifeTitle() + """ +
  4380. " --dest "" + gDirUtilp->getAppRODataDir() + """ +
  4381. " --stringsdir "" + xml_search_paths + """ +
  4382. " --stringsfile "" + xml_strings_file + """;
  4384. LL_INFOS("AppInit") << "Calling updater: " 
  4385.     << LLAppViewer::sUpdaterInfo->mUpdateExePath << LL_ENDL;
  4387. // *TODO: we could use the gdk equivalent to ensure the updater
  4388. // gets started on the same screen.
  4389. GError *error = NULL;
  4390. if (!g_spawn_command_line_async(LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str(), &error))
  4391. {
  4392. llerrs << "Failed to launch updater: "
  4393.        << error->message
  4394.        << llendl;
  4395. }
  4396. if (error) {
  4397. g_error_free(error);
  4398. }
  4399. #else
  4400. OSMessageBox(LLTrans::getString("MBNoAutoUpdate"), LLStringUtil::null, OSMB_OK);
  4401. #endif
  4403. // *REMOVE:Mani - Saving for reference...
  4404. // LLAppViewer::instance()->forceQuit();
  4405. }
  4408. //virtual
  4409. void LLAppViewer::setMasterSystemAudioMute(bool mute)
  4410. {
  4411. gSavedSettings.setBOOL("MuteAudio", mute);
  4412. }
  4414. //virtual
  4415. bool LLAppViewer::getMasterSystemAudioMute()
  4416. {
  4417. return gSavedSettings.getBOOL("MuteAudio");
  4418. }